Core.h revision cc0928ff22d9f3e8f2930874f6727db8c700ec35 
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 call sites */
382void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
383unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
384
385/* Operations on phi nodes */
386void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
387                     LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
388unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
389LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
390LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
391
392/*===-- Instruction builders ----------------------------------------------===*/
393
394/* An instruction builder represents a point within a basic block, and is the
395 * exclusive means of building instructions using the C interface.
396 */
397
398LLVMBuilderRef LLVMCreateBuilder();
399void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
400void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
401void LLVMDisposeBuilder(LLVMBuilderRef Builder);
402
403/* Terminators */
404LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
405LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
406LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
407LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
408                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
409LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
410                             LLVMBasicBlockRef Else, unsigned NumCases);
411LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
412                             LLVMValueRef *Args, unsigned NumArgs,
413                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
414                             const char *Name);
415LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
416LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
417
418/* Arithmetic */
419LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
420                          const char *Name);
421LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
422                          const char *Name);
423LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
424                          const char *Name);
425LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
426                           const char *Name);
427LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
428                           const char *Name);
429LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
430                           const char *Name);
431LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
432                           const char *Name);
433LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
434                           const char *Name);
435LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
436                           const char *Name);
437LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
438                           const char *Name);
439LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
440                           const char *Name);
441LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
442                           const char *Name);
443LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
444                          const char *Name);
445LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
446                          const char *Name);
447LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
448                          const char *Name);
449LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
450LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
451
452/* Memory */
453LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
454LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
455                                  LLVMValueRef Val, const char *Name);
456LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
457LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
458                                  LLVMValueRef Val, const char *Name);
459LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
460LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
461                           const char *Name);
462LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
463LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
464                          LLVMValueRef *Indices, unsigned NumIndices,
465                          const char *Name);
466
467/* Casts */
468LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
469                            LLVMTypeRef DestTy, const char *Name);
470LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
471                           LLVMTypeRef DestTy, const char *Name);
472LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
473                           LLVMTypeRef DestTy, const char *Name);
474LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
475                             LLVMTypeRef DestTy, const char *Name);
476LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
477                             LLVMTypeRef DestTy, const char *Name);
478LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
479                             LLVMTypeRef DestTy, const char *Name);
480LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
481                             LLVMTypeRef DestTy, const char *Name);
482LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
483                              LLVMTypeRef DestTy, const char *Name);
484LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
485                            LLVMTypeRef DestTy, const char *Name);
486LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
487                               LLVMTypeRef DestTy, const char *Name);
488LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
489                               LLVMTypeRef DestTy, const char *Name);
490LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
491                              LLVMTypeRef DestTy, const char *Name);
492
493/* Comparisons */
494LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
495                           LLVMValueRef LHS, LLVMValueRef RHS,
496                           const char *Name);
497LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
498                           LLVMValueRef LHS, LLVMValueRef RHS,
499                           const char *Name);
500
501/* Miscellaneous instructions */
502LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
503LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
504                           LLVMValueRef *Args, unsigned NumArgs,
505                           const char *Name);
506LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
507                             LLVMValueRef Then, LLVMValueRef Else,
508                             const char *Name);
509LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
510                            const char *Name);
511LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
512                                     LLVMValueRef Index, const char *Name);
513LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
514                                    LLVMValueRef EltVal, LLVMValueRef Index,
515                                    const char *Name);
516LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
517                                    LLVMValueRef V2, LLVMValueRef Mask,
518                                    const char *Name);
519
520
521/*===-- Module providers --------------------------------------------------===*/
522
523/* Encapsulates the module M in a module provider, taking ownership of the
524 * module.
525 * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
526 */
527LLVMModuleProviderRef
528LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
529
530/* Destroys the module provider MP as well as the contained module.
531 * See the destructor llvm::ModuleProvider::~ModuleProvider.
532 */
533void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP);
534
535
536/*===-- Memory buffers ----------------------------------------------------===*/
537
538int LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
539                                             LLVMMemoryBufferRef *OutMemBuf,
540                                             char **OutMessage);
541int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
542                                    char **OutMessage);
543void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
544
545#ifdef __cplusplus
546}
547
548namespace llvm {
549  class ModuleProvider;
550  class MemoryBuffer;
551
552  #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)   \
553    inline ty *unwrap(ref P) {                          \
554      return reinterpret_cast<ty*>(P);                  \
555    }                                                   \
556                                                        \
557    inline ref wrap(const ty *P) {                      \
558      return reinterpret_cast<ref>(const_cast<ty*>(P)); \
559    }
560
561  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Type,               LLVMTypeRef          )
562  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Value,              LLVMValueRef         )
563  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module,             LLVMModuleRef        )
564  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock,         LLVMBasicBlockRef    )
565  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMFoldingBuilder, LLVMBuilderRef       )
566  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder,       LLVMTypeHandleRef    )
567  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider,     LLVMModuleProviderRef)
568  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer,       LLVMMemoryBufferRef  )
569
570  #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
571
572  /* Specialized opaque type conversions.
573   */
574  template<typename T>
575  inline T *unwrap(LLVMTypeRef Ty) {
576    return cast<T>(unwrap(Ty));
577  }
578
579  inline Type **unwrap(LLVMTypeRef* Tys) {
580    return reinterpret_cast<Type**>(Tys);
581  }
582
583  inline LLVMTypeRef *wrap(const Type **Tys) {
584    return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
585  }
586
587  /* Specialized opaque value conversions.
588   */
589  template<typename T>
590  inline T *unwrap(LLVMValueRef Val) {
591    return cast<T>(unwrap(Val));
592  }
593
594  inline Value **unwrap(LLVMValueRef *Vals) {
595    return reinterpret_cast<Value**>(Vals);
596  }
597
598  template<typename T>
599  inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
600    #if DEBUG
601    for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
602      cast<T>(*I);
603    #endif
604    return reinterpret_cast<T**>(Vals);
605  }
606
607  inline LLVMValueRef *wrap(const Value **Vals) {
608    return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
609  }
610}
611
612#endif /* !defined(__cplusplus) */
613
614#endif /* !defined(LLVM_C_CORE_H) */
615