Core.h revision 1d2e49cd84290e19ffcf1011a650cf04dac6a1cd 
1/*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
2|*                                                                            *|
3|*                     The LLVM Compiler Infrastructure                       *|
4|*                                                                            *|
5|* This file was developed by Gordon Henriksen and is distributed under the   *|
6|* University of Illinois Open Source 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/* Same as Module::addTypeName. */
153int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
154void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
155
156
157/*===-- Types -------------------------------------------------------------===*/
158
159/* LLVM types conform to the following hierarchy:
160 *
161 *   types:
162 *     integer type
163 *     real type
164 *     function type
165 *     sequence types:
166 *       array type
167 *       pointer type
168 *       vector type
169 *     void type
170 *     label type
171 *     opaque type
172 */
173
174LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
175void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType);
176
177/* Operations on integer types */
178LLVMTypeRef LLVMInt1Type();
179LLVMTypeRef LLVMInt8Type();
180LLVMTypeRef LLVMInt16Type();
181LLVMTypeRef LLVMInt32Type();
182LLVMTypeRef LLVMInt64Type();
183LLVMTypeRef LLVMIntType(unsigned NumBits);
184unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
185
186/* Operations on real types */
187LLVMTypeRef LLVMFloatType();
188LLVMTypeRef LLVMDoubleType();
189LLVMTypeRef LLVMX86FP80Type();
190LLVMTypeRef LLVMFP128Type();
191LLVMTypeRef LLVMPPCFP128Type();
192
193/* Operations on function types */
194LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
195                             LLVMTypeRef *ParamTypes, unsigned ParamCount,
196                             int IsVarArg);
197int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
198LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
199unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
200void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
201
202/* Operations on struct types */
203LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
204                           int Packed);
205unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
206void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
207int LLVMIsPackedStruct(LLVMTypeRef StructTy);
208
209/* Operations on array, pointer, and vector types (sequence types) */
210LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
211LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
212LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
213
214LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
215unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
216unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
217unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
218
219/* Operations on other types */
220LLVMTypeRef LLVMVoidType();
221LLVMTypeRef LLVMLabelType();
222LLVMTypeRef LLVMOpaqueType();
223
224/* Operations on type handles */
225LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
226void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
227LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
228void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
229
230
231/*===-- Values ------------------------------------------------------------===*/
232
233/* The bulk of LLVM's object model consists of values, which comprise a very
234 * rich type hierarchy.
235 *
236 *   values:
237 *     constants:
238 *       scalar constants
239 *       composite contants
240 *       globals:
241 *         global variable
242 *         function
243 *         alias
244 *       basic blocks
245 */
246
247/* Operations on all values */
248LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
249const char *LLVMGetValueName(LLVMValueRef Val);
250void LLVMSetValueName(LLVMValueRef Val, const char *Name);
251void LLVMDumpValue(LLVMValueRef Val);
252
253/* Operations on constants of any type */
254LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
255LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
256LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
257int LLVMIsConstant(LLVMValueRef Val);
258int LLVMIsNull(LLVMValueRef Val);
259int LLVMIsUndef(LLVMValueRef Val);
260
261/* Operations on scalar constants */
262LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
263                          int SignExtend);
264LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
265
266/* Operations on composite constants */
267LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
268                             int DontNullTerminate);
269LLVMValueRef LLVMConstArray(LLVMTypeRef ArrayTy,
270                            LLVMValueRef *ConstantVals, unsigned Length);
271LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
272                             int packed);
273LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
274
275/* Constant expressions */
276LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
277LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
278LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
279LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
280LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
281LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
282LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
283LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
284LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
285LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
286LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
287LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
288LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
289LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
290LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
291LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
292                           LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
293LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
294                           LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
295LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
296LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
297LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
298LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
299                          LLVMValueRef *ConstantIndices, unsigned NumIndices);
300LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
301LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
302LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
303LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
304LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
305LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
306LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
307LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
308LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
309LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
310LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
311LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
312LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
313                             LLVMValueRef ConstantIfTrue,
314                             LLVMValueRef ConstantIfFalse);
315LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
316                                     LLVMValueRef IndexConstant);
317LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
318                                    LLVMValueRef ElementValueConstant,
319                                    LLVMValueRef IndexConstant);
320LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
321                                    LLVMValueRef VectorBConstant,
322                                    LLVMValueRef MaskConstant);
323
324/* Operations on global variables, functions, and aliases (globals) */
325int LLVMIsDeclaration(LLVMValueRef Global);
326LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
327void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
328const char *LLVMGetSection(LLVMValueRef Global);
329void LLVMSetSection(LLVMValueRef Global, const char *Section);
330LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
331void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
332unsigned LLVMGetAlignment(LLVMValueRef Global);
333void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
334
335/* Operations on global variables */
336LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
337LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
338void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
339int LLVMHasInitializer(LLVMValueRef GlobalVar);
340LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
341void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
342int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
343void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
344int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
345void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
346
347/* Operations on functions */
348LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
349                             LLVMTypeRef FunctionTy);
350LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
351void LLVMDeleteFunction(LLVMValueRef Fn);
352unsigned LLVMCountParams(LLVMValueRef Fn);
353void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
354LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
355unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
356unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
357void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
358const char *LLVMGetCollector(LLVMValueRef Fn);
359void LLVMSetCollector(LLVMValueRef Fn, const char *Coll);
360
361/* Operations on basic blocks */
362LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb);
363int LLVMValueIsBasicBlock(LLVMValueRef Val);
364LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
365unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
366void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
367LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
368LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
369LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
370                                       const char *Name);
371void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
372
373/* Operations on phi nodes */
374void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
375                     LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
376unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
377LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
378LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
379
380/*===-- Instruction builders ----------------------------------------------===*/
381
382/* An instruction builder represents a point within a basic block, and is the
383 * exclusive means of building instructions using the C interface.
384 */
385
386LLVMBuilderRef LLVMCreateBuilder();
387void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
388void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
389void LLVMDisposeBuilder(LLVMBuilderRef Builder);
390
391/* Terminators */
392LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
393LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
394LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
395LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
396                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
397LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
398                             LLVMBasicBlockRef Else, unsigned NumCases);
399LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
400                             LLVMValueRef *Args, unsigned NumArgs,
401                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
402                             const char *Name);
403LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
404LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
405
406/* Arithmetic */
407LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
408                          const char *Name);
409LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
410                          const char *Name);
411LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
412                          const char *Name);
413LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
414                           const char *Name);
415LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
416                           const char *Name);
417LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
418                           const char *Name);
419LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
420                           const char *Name);
421LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
422                           const char *Name);
423LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
424                           const char *Name);
425LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
426                           const char *Name);
427LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
428                           const char *Name);
429LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
430                           const char *Name);
431LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
432                          const char *Name);
433LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
434                          const char *Name);
435LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
436                          const char *Name);
437LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
438LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
439
440/* Memory */
441LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
442LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
443                                  LLVMValueRef Val, const char *Name);
444LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
445LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
446                                  LLVMValueRef Val, const char *Name);
447LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
448LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
449                           const char *Name);
450LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
451LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
452                          LLVMValueRef *Indices, unsigned NumIndices,
453                          const char *Name);
454
455/* Casts */
456LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
457                            LLVMTypeRef DestTy, const char *Name);
458LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
459                           LLVMTypeRef DestTy, const char *Name);
460LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
461                           LLVMTypeRef DestTy, const char *Name);
462LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
463                             LLVMTypeRef DestTy, const char *Name);
464LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
465                             LLVMTypeRef DestTy, const char *Name);
466LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
467                             LLVMTypeRef DestTy, const char *Name);
468LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
469                             LLVMTypeRef DestTy, const char *Name);
470LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
471                              LLVMTypeRef DestTy, const char *Name);
472LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
473                            LLVMTypeRef DestTy, const char *Name);
474LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
475                               LLVMTypeRef DestTy, const char *Name);
476LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
477                               LLVMTypeRef DestTy, const char *Name);
478LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
479                              LLVMTypeRef DestTy, const char *Name);
480
481/* Comparisons */
482LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
483                           LLVMValueRef LHS, LLVMValueRef RHS,
484                           const char *Name);
485LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
486                           LLVMValueRef LHS, LLVMValueRef RHS,
487                           const char *Name);
488
489/* Miscellaneous instructions */
490LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
491LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
492                           LLVMValueRef *Args, unsigned NumArgs,
493                           const char *Name);
494LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
495                             LLVMValueRef Then, LLVMValueRef Else,
496                             const char *Name);
497LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
498                            const char *Name);
499LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
500                                     LLVMValueRef Index, const char *Name);
501LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
502                                    LLVMValueRef EltVal, LLVMValueRef Index,
503                                    const char *Name);
504LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
505                                    LLVMValueRef V2, LLVMValueRef Mask,
506                                    const char *Name);
507
508
509/*===-- Module providers --------------------------------------------------===*/
510
511/* Encapsulates the module M in a module provider, taking ownership of the
512 * module.
513 * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
514 */
515LLVMModuleProviderRef
516LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
517
518/* Destroys the module provider MP as well as the contained module.
519 * See the destructor llvm::ModuleProvider::~ModuleProvider.
520 */
521void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP);
522
523
524/*===-- Memory buffers ----------------------------------------------------===*/
525
526int LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
527                                             LLVMMemoryBufferRef *OutMemBuf,
528                                             char **OutMessage);
529int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
530                                    char **OutMessage);
531void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
532
533#ifdef __cplusplus
534}
535
536namespace llvm {
537  class ModuleProvider;
538  class MemoryBuffer;
539
540  #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)   \
541    inline ty *unwrap(ref P) {                          \
542      return reinterpret_cast<ty*>(P);                  \
543    }                                                   \
544                                                        \
545    inline ref wrap(const ty *P) {                      \
546      return reinterpret_cast<ref>(const_cast<ty*>(P)); \
547    }
548
549  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Type,               LLVMTypeRef          )
550  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Value,              LLVMValueRef         )
551  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module,             LLVMModuleRef        )
552  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock,         LLVMBasicBlockRef    )
553  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMFoldingBuilder, LLVMBuilderRef       )
554  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder,       LLVMTypeHandleRef    )
555  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider,     LLVMModuleProviderRef)
556  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer,       LLVMMemoryBufferRef  )
557
558  #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
559
560  /* Specialized opaque type conversions.
561   */
562  template<typename T>
563  inline T *unwrap(LLVMTypeRef Ty) {
564    return cast<T>(unwrap(Ty));
565  }
566
567  inline Type **unwrap(LLVMTypeRef* Tys) {
568    return reinterpret_cast<Type**>(Tys);
569  }
570
571  inline LLVMTypeRef *wrap(const Type **Tys) {
572    return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
573  }
574
575  /* Specialized opaque value conversions.
576   */
577  template<typename T>
578  inline T *unwrap(LLVMValueRef Val) {
579    return cast<T>(unwrap(Val));
580  }
581
582  inline Value **unwrap(LLVMValueRef *Vals) {
583    return reinterpret_cast<Value**>(Vals);
584  }
585
586  template<typename T>
587  inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
588    #if DEBUG
589    for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
590      cast<T>(*I);
591    #endif
592    return reinterpret_cast<T**>(Vals);
593  }
594
595  inline LLVMValueRef *wrap(const Value **Vals) {
596    return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
597  }
598}
599
600#endif /* !defined(__cplusplus) */
601
602#endif /* !defined(LLVM_C_CORE_H) */
603