Core.h revision 7ed47a13356daed2a34cd2209a31f92552e3bdd8 
1/*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
2|*                                                                            *|
3|*                     The LLVM Compiler Infrastructure                       *|
4|*                                                                            *|
5|* This file is distributed under the University of Illinois Open Source      *|
6|* License. See LICENSE.TXT for details.                                      *|
7|*                                                                            *|
8|*===----------------------------------------------------------------------===*|
9|*                                                                            *|
10|* This header declares the C interface to libLLVMCore.a, which implements    *|
11|* the LLVM intermediate representation.                                      *|
12|*                                                                            *|
13|* LLVM uses a polymorphic type hierarchy which C cannot represent, therefore *|
14|* parameters must be passed as base types. Despite the declared types, most  *|
15|* of the functions provided operate only on branches of the type hierarchy.  *|
16|* The declared parameter names are descriptive and specify which type is     *|
17|* required. Additionally, each type hierarchy is documented along with the   *|
18|* functions that operate upon it. For more detail, refer to LLVM's C++ code. *|
19|* If in doubt, refer to Core.cpp, which performs paramter downcasts in the   *|
20|* form unwrap<RequiredType>(Param).                                          *|
21|*                                                                            *|
22|* Many exotic languages can interoperate with C code but have a harder time  *|
23|* with C++ due to name mangling. So in addition to C, this interface enables *|
24|* tools written in such languages.                                           *|
25|*                                                                            *|
26|* When included into a C++ source file, also declares 'wrap' and 'unwrap'    *|
27|* helpers to perform opaque reference<-->pointer conversions. These helpers  *|
28|* are shorter and more tightly typed than writing the casts by hand when     *|
29|* authoring bindings. In assert builds, they will do runtime type checking.  *|
30|*                                                                            *|
31\*===----------------------------------------------------------------------===*/
32
33#ifndef LLVM_C_CORE_H
34#define LLVM_C_CORE_H
35
36#ifdef __cplusplus
37
38/* Need these includes to support the LLVM 'cast' template for the C++ 'wrap'
39   and 'unwrap' conversion functions. */
40#include "llvm/Module.h"
41#include "llvm/Support/LLVMBuilder.h"
42
43extern "C" {
44#endif
45
46
47/* Opaque types. */
48typedef struct LLVMOpaqueModule *LLVMModuleRef;
49typedef struct LLVMOpaqueType *LLVMTypeRef;
50typedef struct LLVMOpaqueTypeHandle *LLVMTypeHandleRef;
51typedef struct LLVMOpaqueValue *LLVMValueRef;
52typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
53typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
54
55/* Used to provide a module to JIT or interpreter.
56 * See the llvm::ModuleProvider class.
57 */
58typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
59
60/* Used to provide a module to JIT or interpreter.
61 * See the llvm::MemoryBuffer class.
62 */
63typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef;
64
65typedef enum {
66  LLVMVoidTypeKind,        /* type with no size */
67  LLVMFloatTypeKind,       /* 32 bit floating point type */
68  LLVMDoubleTypeKind,      /* 64 bit floating point type */
69  LLVMX86_FP80TypeKind,    /* 80 bit floating point type (X87) */
70  LLVMFP128TypeKind,       /* 128 bit floating point type (112-bit mantissa) */
71  LLVMPPC_FP128TypeKind,   /* 128 bit floating point type (two 64-bits) */
72  LLVMLabelTypeKind,       /* Labels */
73  LLVMIntegerTypeKind,     /* Arbitrary bit width integers */
74  LLVMFunctionTypeKind,    /* Functions */
75  LLVMStructTypeKind,      /* Structures */
76  LLVMArrayTypeKind,       /* Arrays */
77  LLVMPointerTypeKind,     /* Pointers */
78  LLVMOpaqueTypeKind,      /* Opaque: type with unknown structure */
79  LLVMVectorTypeKind       /* SIMD 'packed' format, or other vector type */
80} LLVMTypeKind;
81
82typedef enum {
83  LLVMExternalLinkage,    /* Externally visible function */
84  LLVMLinkOnceLinkage,    /* Keep one copy of function when linking (inline) */
85  LLVMWeakLinkage,        /* Keep one copy of function when linking (weak) */
86  LLVMAppendingLinkage,   /* Special purpose, only applies to global arrays */
87  LLVMInternalLinkage,    /* Rename collisions when linking (static functions)*/
88  LLVMDLLImportLinkage,   /* Function to be imported from DLL */
89  LLVMDLLExportLinkage,   /* Function to be accessible from DLL */
90  LLVMExternalWeakLinkage,/* ExternalWeak linkage description */
91  LLVMGhostLinkage        /* Stand-in functions for streaming fns from bitcode*/
92} LLVMLinkage;
93
94typedef enum {
95  LLVMDefaultVisibility,  /* The GV is visible */
96  LLVMHiddenVisibility,   /* The GV is hidden */
97  LLVMProtectedVisibility /* The GV is protected */
98} LLVMVisibility;
99
100typedef enum {
101  LLVMCCallConv           = 0,
102  LLVMFastCallConv        = 8,
103  LLVMColdCallConv        = 9,
104  LLVMX86StdcallCallConv  = 64,
105  LLVMX86FastcallCallConv = 65
106} LLVMCallConv;
107
108typedef enum {
109  LLVMIntEQ = 32, /* equal */
110  LLVMIntNE,      /* not equal */
111  LLVMIntUGT,     /* unsigned greater than */
112  LLVMIntUGE,     /* unsigned greater or equal */
113  LLVMIntULT,     /* unsigned less than */
114  LLVMIntULE,     /* unsigned less or equal */
115  LLVMIntSGT,     /* signed greater than */
116  LLVMIntSGE,     /* signed greater or equal */
117  LLVMIntSLT,     /* signed less than */
118  LLVMIntSLE      /* signed less or equal */
119} LLVMIntPredicate;
120
121typedef enum {
122  LLVMRealPredicateFalse, /* Always false (always folded) */
123  LLVMRealOEQ,            /* True if ordered and equal */
124  LLVMRealOGT,            /* True if ordered and greater than */
125  LLVMRealOGE,            /* True if ordered and greater than or equal */
126  LLVMRealOLT,            /* True if ordered and less than */
127  LLVMRealOLE,            /* True if ordered and less than or equal */
128  LLVMRealONE,            /* True if ordered and operands are unequal */
129  LLVMRealORD,            /* True if ordered (no nans) */
130  LLVMRealUNO,            /* True if unordered: isnan(X) | isnan(Y) */
131  LLVMRealUEQ,            /* True if unordered or equal */
132  LLVMRealUGT,            /* True if unordered or greater than */
133  LLVMRealUGE,            /* True if unordered, greater than, or equal */
134  LLVMRealULT,            /* True if unordered or less than */
135  LLVMRealULE,            /* True if unordered, less than, or equal */
136  LLVMRealUNE,            /* True if unordered or not equal */
137  LLVMRealPredicateTrue   /* Always true (always folded) */
138} LLVMRealPredicate;
139
140
141/*===-- Error handling ----------------------------------------------------===*/
142
143void LLVMDisposeMessage(char *Message);
144
145
146/*===-- Modules -----------------------------------------------------------===*/
147
148/* Create and destroy modules. */
149LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
150void LLVMDisposeModule(LLVMModuleRef M);
151
152/* Data layout */
153const char *LLVMGetDataLayout(LLVMModuleRef M);
154void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple);
155
156/* Target triple */
157const char *LLVMGetTarget(LLVMModuleRef M);
158void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
159
160/* Same as Module::addTypeName. */
161int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
162void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
163
164
165/*===-- Types -------------------------------------------------------------===*/
166
167/* LLVM types conform to the following hierarchy:
168 *
169 *   types:
170 *     integer type
171 *     real type
172 *     function type
173 *     sequence types:
174 *       array type
175 *       pointer type
176 *       vector type
177 *     void type
178 *     label type
179 *     opaque type
180 */
181
182LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
183void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType);
184
185/* Operations on integer types */
186LLVMTypeRef LLVMInt1Type();
187LLVMTypeRef LLVMInt8Type();
188LLVMTypeRef LLVMInt16Type();
189LLVMTypeRef LLVMInt32Type();
190LLVMTypeRef LLVMInt64Type();
191LLVMTypeRef LLVMIntType(unsigned NumBits);
192unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
193
194/* Operations on real types */
195LLVMTypeRef LLVMFloatType();
196LLVMTypeRef LLVMDoubleType();
197LLVMTypeRef LLVMX86FP80Type();
198LLVMTypeRef LLVMFP128Type();
199LLVMTypeRef LLVMPPCFP128Type();
200
201/* Operations on function types */
202LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
203                             LLVMTypeRef *ParamTypes, unsigned ParamCount,
204                             int IsVarArg);
205int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
206LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
207unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
208void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
209
210/* Operations on struct types */
211LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
212                           int Packed);
213unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
214void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
215int LLVMIsPackedStruct(LLVMTypeRef StructTy);
216
217/* Operations on array, pointer, and vector types (sequence types) */
218LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
219LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
220LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
221
222LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
223unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
224unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
225unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
226
227/* Operations on other types */
228LLVMTypeRef LLVMVoidType();
229LLVMTypeRef LLVMLabelType();
230LLVMTypeRef LLVMOpaqueType();
231
232/* Operations on type handles */
233LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
234void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
235LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
236void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
237
238
239/*===-- Values ------------------------------------------------------------===*/
240
241/* The bulk of LLVM's object model consists of values, which comprise a very
242 * rich type hierarchy.
243 *
244 *   values:
245 *     constants:
246 *       scalar constants
247 *       composite contants
248 *       globals:
249 *         global variable
250 *         function
251 *         alias
252 *       basic blocks
253 */
254
255/* Operations on all values */
256LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
257const char *LLVMGetValueName(LLVMValueRef Val);
258void LLVMSetValueName(LLVMValueRef Val, const char *Name);
259void LLVMDumpValue(LLVMValueRef Val);
260
261/* Operations on constants of any type */
262LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
263LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
264LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
265int LLVMIsConstant(LLVMValueRef Val);
266int LLVMIsNull(LLVMValueRef Val);
267int LLVMIsUndef(LLVMValueRef Val);
268
269/* Operations on scalar constants */
270LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
271                          int SignExtend);
272LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
273
274/* Operations on composite constants */
275LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
276                             int DontNullTerminate);
277LLVMValueRef LLVMConstArray(LLVMTypeRef ArrayTy,
278                            LLVMValueRef *ConstantVals, unsigned Length);
279LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
280                             int packed);
281LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
282
283/* Constant expressions */
284LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
285LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
286LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
287LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
288LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
289LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
290LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
291LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
292LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
293LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
294LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
295LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
296LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
297LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
298LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
299LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
300                           LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
301LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
302                           LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
303LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
304LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
305LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
306LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
307                          LLVMValueRef *ConstantIndices, unsigned NumIndices);
308LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
309LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
310LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
311LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
312LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
313LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
314LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
315LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
316LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
317LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
318LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
319LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
320LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
321                             LLVMValueRef ConstantIfTrue,
322                             LLVMValueRef ConstantIfFalse);
323LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
324                                     LLVMValueRef IndexConstant);
325LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
326                                    LLVMValueRef ElementValueConstant,
327                                    LLVMValueRef IndexConstant);
328LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
329                                    LLVMValueRef VectorBConstant,
330                                    LLVMValueRef MaskConstant);
331
332/* Operations on global variables, functions, and aliases (globals) */
333int LLVMIsDeclaration(LLVMValueRef Global);
334LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
335void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
336const char *LLVMGetSection(LLVMValueRef Global);
337void LLVMSetSection(LLVMValueRef Global, const char *Section);
338LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
339void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
340unsigned LLVMGetAlignment(LLVMValueRef Global);
341void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
342
343/* Operations on global variables */
344LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
345LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
346void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
347int LLVMHasInitializer(LLVMValueRef GlobalVar);
348LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
349void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
350int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
351void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
352int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
353void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
354
355/* Operations on functions */
356LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
357                             LLVMTypeRef FunctionTy);
358LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
359void LLVMDeleteFunction(LLVMValueRef Fn);
360unsigned LLVMCountParams(LLVMValueRef Fn);
361void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
362LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
363unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
364unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
365void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
366const char *LLVMGetCollector(LLVMValueRef Fn);
367void LLVMSetCollector(LLVMValueRef Fn, const char *Coll);
368
369/* Operations on basic blocks */
370LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb);
371int LLVMValueIsBasicBlock(LLVMValueRef Val);
372LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
373unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
374void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
375LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
376LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
377LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
378                                       const char *Name);
379void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
380
381/* Operations on phi nodes */
382void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
383                     LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
384unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
385LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
386LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
387
388/*===-- Instruction builders ----------------------------------------------===*/
389
390/* An instruction builder represents a point within a basic block, and is the
391 * exclusive means of building instructions using the C interface.
392 */
393
394LLVMBuilderRef LLVMCreateBuilder();
395void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
396void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
397void LLVMDisposeBuilder(LLVMBuilderRef Builder);
398
399/* Terminators */
400LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
401LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
402LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
403LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
404                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
405LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
406                             LLVMBasicBlockRef Else, unsigned NumCases);
407LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
408                             LLVMValueRef *Args, unsigned NumArgs,
409                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
410                             const char *Name);
411LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
412LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
413
414/* Arithmetic */
415LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
416                          const char *Name);
417LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
418                          const char *Name);
419LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
420                          const char *Name);
421LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
422                           const char *Name);
423LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
424                           const char *Name);
425LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
426                           const char *Name);
427LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
428                           const char *Name);
429LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
430                           const char *Name);
431LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
432                           const char *Name);
433LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
434                           const char *Name);
435LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
436                           const char *Name);
437LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
438                           const char *Name);
439LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
440                          const char *Name);
441LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
442                          const char *Name);
443LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
444                          const char *Name);
445LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
446LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
447
448/* Memory */
449LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
450LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
451                                  LLVMValueRef Val, const char *Name);
452LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
453LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
454                                  LLVMValueRef Val, const char *Name);
455LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
456LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
457                           const char *Name);
458LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
459LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
460                          LLVMValueRef *Indices, unsigned NumIndices,
461                          const char *Name);
462
463/* Casts */
464LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
465                            LLVMTypeRef DestTy, const char *Name);
466LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
467                           LLVMTypeRef DestTy, const char *Name);
468LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
469                           LLVMTypeRef DestTy, const char *Name);
470LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
471                             LLVMTypeRef DestTy, const char *Name);
472LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
473                             LLVMTypeRef DestTy, const char *Name);
474LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
475                             LLVMTypeRef DestTy, const char *Name);
476LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
477                             LLVMTypeRef DestTy, const char *Name);
478LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
479                              LLVMTypeRef DestTy, const char *Name);
480LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
481                            LLVMTypeRef DestTy, const char *Name);
482LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
483                               LLVMTypeRef DestTy, const char *Name);
484LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
485                               LLVMTypeRef DestTy, const char *Name);
486LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
487                              LLVMTypeRef DestTy, const char *Name);
488
489/* Comparisons */
490LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
491                           LLVMValueRef LHS, LLVMValueRef RHS,
492                           const char *Name);
493LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
494                           LLVMValueRef LHS, LLVMValueRef RHS,
495                           const char *Name);
496
497/* Miscellaneous instructions */
498LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
499LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
500                           LLVMValueRef *Args, unsigned NumArgs,
501                           const char *Name);
502LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
503                             LLVMValueRef Then, LLVMValueRef Else,
504                             const char *Name);
505LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
506                            const char *Name);
507LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
508                                     LLVMValueRef Index, const char *Name);
509LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
510                                    LLVMValueRef EltVal, LLVMValueRef Index,
511                                    const char *Name);
512LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
513                                    LLVMValueRef V2, LLVMValueRef Mask,
514                                    const char *Name);
515
516
517/*===-- Module providers --------------------------------------------------===*/
518
519/* Encapsulates the module M in a module provider, taking ownership of the
520 * module.
521 * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
522 */
523LLVMModuleProviderRef
524LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
525
526/* Destroys the module provider MP as well as the contained module.
527 * See the destructor llvm::ModuleProvider::~ModuleProvider.
528 */
529void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP);
530
531
532/*===-- Memory buffers ----------------------------------------------------===*/
533
534int LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
535                                             LLVMMemoryBufferRef *OutMemBuf,
536                                             char **OutMessage);
537int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
538                                    char **OutMessage);
539void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
540
541#ifdef __cplusplus
542}
543
544namespace llvm {
545  class ModuleProvider;
546  class MemoryBuffer;
547
548  #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)   \
549    inline ty *unwrap(ref P) {                          \
550      return reinterpret_cast<ty*>(P);                  \
551    }                                                   \
552                                                        \
553    inline ref wrap(const ty *P) {                      \
554      return reinterpret_cast<ref>(const_cast<ty*>(P)); \
555    }
556
557  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Type,               LLVMTypeRef          )
558  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Value,              LLVMValueRef         )
559  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module,             LLVMModuleRef        )
560  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock,         LLVMBasicBlockRef    )
561  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMFoldingBuilder, LLVMBuilderRef       )
562  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder,       LLVMTypeHandleRef    )
563  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider,     LLVMModuleProviderRef)
564  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer,       LLVMMemoryBufferRef  )
565
566  #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
567
568  /* Specialized opaque type conversions.
569   */
570  template<typename T>
571  inline T *unwrap(LLVMTypeRef Ty) {
572    return cast<T>(unwrap(Ty));
573  }
574
575  inline Type **unwrap(LLVMTypeRef* Tys) {
576    return reinterpret_cast<Type**>(Tys);
577  }
578
579  inline LLVMTypeRef *wrap(const Type **Tys) {
580    return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
581  }
582
583  /* Specialized opaque value conversions.
584   */
585  template<typename T>
586  inline T *unwrap(LLVMValueRef Val) {
587    return cast<T>(unwrap(Val));
588  }
589
590  inline Value **unwrap(LLVMValueRef *Vals) {
591    return reinterpret_cast<Value**>(Vals);
592  }
593
594  template<typename T>
595  inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
596    #if DEBUG
597    for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
598      cast<T>(*I);
599    #endif
600    return reinterpret_cast<T**>(Vals);
601  }
602
603  inline LLVMValueRef *wrap(const Value **Vals) {
604    return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
605  }
606}
607
608#endif /* !defined(__cplusplus) */
609
610#endif /* !defined(LLVM_C_CORE_H) */
611