Core.h revision 203954 
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#include "llvm/System/DataTypes.h"
37
38#ifdef __cplusplus
39
40/* Need these includes to support the LLVM 'cast' template for the C++ 'wrap'
41   and 'unwrap' conversion functions. */
42#include "llvm/Module.h"
43#include "llvm/Support/IRBuilder.h"
44
45extern "C" {
46#endif
47
48
49typedef int LLVMBool;
50
51/* Opaque types. */
52
53/**
54 * The top-level container for all LLVM global data.  See the LLVMContext class.
55 */
56typedef struct LLVMOpaqueContext *LLVMContextRef;
57
58/**
59 * The top-level container for all other LLVM Intermediate Representation (IR)
60 * objects. See the llvm::Module class.
61 */
62typedef struct LLVMOpaqueModule *LLVMModuleRef;
63
64/**
65 * Each value in the LLVM IR has a type, an LLVMTypeRef. See the llvm::Type
66 * class.
67 */
68typedef struct LLVMOpaqueType *LLVMTypeRef;
69
70/**
71 * When building recursive types using LLVMRefineType, LLVMTypeRef values may
72 * become invalid; use LLVMTypeHandleRef to resolve this problem. See the
73 * llvm::AbstractTypeHolder class.
74 */
75typedef struct LLVMOpaqueTypeHandle *LLVMTypeHandleRef;
76
77typedef struct LLVMOpaqueValue *LLVMValueRef;
78typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
79typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
80
81/* Interface used to provide a module to JIT or interpreter.  This is now just a
82 * synonym for llvm::Module, but we have to keep using the different type to
83 * keep binary compatibility.
84 */
85typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
86
87/* Used to provide a module to JIT or interpreter.
88 * See the llvm::MemoryBuffer class.
89 */
90typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef;
91
92/** See the llvm::PassManagerBase class. */
93typedef struct LLVMOpaquePassManager *LLVMPassManagerRef;
94
95/**
96 * Used to iterate through the uses of a Value, allowing access to all Values
97 * that use this Value.  See the llvm::Use and llvm::value_use_iterator classes.
98 */
99typedef struct LLVMOpaqueUseIterator *LLVMUseIteratorRef;
100
101typedef enum {
102    LLVMZExtAttribute       = 1<<0,
103    LLVMSExtAttribute       = 1<<1,
104    LLVMNoReturnAttribute   = 1<<2,
105    LLVMInRegAttribute      = 1<<3,
106    LLVMStructRetAttribute  = 1<<4,
107    LLVMNoUnwindAttribute   = 1<<5,
108    LLVMNoAliasAttribute    = 1<<6,
109    LLVMByValAttribute      = 1<<7,
110    LLVMNestAttribute       = 1<<8,
111    LLVMReadNoneAttribute   = 1<<9,
112    LLVMReadOnlyAttribute   = 1<<10,
113    LLVMNoInlineAttribute   = 1<<11,
114    LLVMAlwaysInlineAttribute    = 1<<12,
115    LLVMOptimizeForSizeAttribute = 1<<13,
116    LLVMStackProtectAttribute    = 1<<14,
117    LLVMStackProtectReqAttribute = 1<<15,
118    LLVMNoCaptureAttribute  = 1<<21,
119    LLVMNoRedZoneAttribute  = 1<<22,
120    LLVMNoImplicitFloatAttribute = 1<<23,
121    LLVMNakedAttribute      = 1<<24,
122    LLVMInlineHintAttribute = 1<<25
123} LLVMAttribute;
124
125typedef enum {
126  /* Terminator Instructions */
127  LLVMRet            = 1,
128  LLVMBr             = 2,
129  LLVMSwitch         = 3,
130  LLVMIndirectBr     = 4,
131  LLVMInvoke         = 5,
132  LLVMUnwind         = 6,
133  LLVMUnreachable    = 7,
134
135  /* Standard Binary Operators */
136  LLVMAdd            = 8,
137  LLVMFAdd           = 9,
138  LLVMSub            = 10,
139  LLVMFSub           = 11,
140  LLVMMul            = 12,
141  LLVMFMul           = 13,
142  LLVMUDiv           = 14,
143  LLVMSDiv           = 15,
144  LLVMFDiv           = 16,
145  LLVMURem           = 17,
146  LLVMSRem           = 18,
147  LLVMFRem           = 19,
148
149  /* Logical Operators */
150  LLVMShl            = 20,
151  LLVMLShr           = 21,
152  LLVMAShr           = 22,
153  LLVMAnd            = 23,
154  LLVMOr             = 24,
155  LLVMXor            = 25,
156
157  /* Memory Operators */
158  LLVMAlloca         = 26,
159  LLVMLoad           = 27,
160  LLVMStore          = 28,
161  LLVMGetElementPtr  = 29,
162
163  /* Cast Operators */
164  LLVMTrunc          = 30,
165  LLVMZExt           = 31,
166  LLVMSExt           = 32,
167  LLVMFPToUI         = 33,
168  LLVMFPToSI         = 34,
169  LLVMUIToFP         = 35,
170  LLVMSIToFP         = 36,
171  LLVMFPTrunc        = 37,
172  LLVMFPExt          = 38,
173  LLVMPtrToInt       = 39,
174  LLVMIntToPtr       = 40,
175  LLVMBitCast        = 41,
176
177  /* Other Operators */
178  LLVMICmp           = 42,
179  LLVMFCmp           = 43,
180  LLVMPHI            = 44,
181  LLVMCall           = 45,
182  LLVMSelect         = 46,
183  /* UserOp1 */
184  /* UserOp2 */
185  LLVMVAArg          = 49,
186  LLVMExtractElement = 50,
187  LLVMInsertElement  = 51,
188  LLVMShuffleVector  = 52,
189  LLVMExtractValue   = 53,
190  LLVMInsertValue    = 54
191} LLVMOpcode;
192
193typedef enum {
194  LLVMVoidTypeKind,        /**< type with no size */
195  LLVMFloatTypeKind,       /**< 32 bit floating point type */
196  LLVMDoubleTypeKind,      /**< 64 bit floating point type */
197  LLVMX86_FP80TypeKind,    /**< 80 bit floating point type (X87) */
198  LLVMFP128TypeKind,       /**< 128 bit floating point type (112-bit mantissa)*/
199  LLVMPPC_FP128TypeKind,   /**< 128 bit floating point type (two 64-bits) */
200  LLVMLabelTypeKind,       /**< Labels */
201  LLVMIntegerTypeKind,     /**< Arbitrary bit width integers */
202  LLVMFunctionTypeKind,    /**< Functions */
203  LLVMStructTypeKind,      /**< Structures */
204  LLVMArrayTypeKind,       /**< Arrays */
205  LLVMPointerTypeKind,     /**< Pointers */
206  LLVMOpaqueTypeKind,      /**< Opaque: type with unknown structure */
207  LLVMVectorTypeKind,      /**< SIMD 'packed' format, or other vector type */
208  LLVMMetadataTypeKind,    /**< Metadata */
209  LLVMUnionTypeKind        /**< Unions */
210} LLVMTypeKind;
211
212typedef enum {
213  LLVMExternalLinkage,    /**< Externally visible function */
214  LLVMAvailableExternallyLinkage,
215  LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
216  LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
217                            equivalent. */
218  LLVMWeakAnyLinkage,     /**< Keep one copy of function when linking (weak) */
219  LLVMWeakODRLinkage,     /**< Same, but only replaced by something
220                            equivalent. */
221  LLVMAppendingLinkage,   /**< Special purpose, only applies to global arrays */
222  LLVMInternalLinkage,    /**< Rename collisions when linking (static
223                               functions) */
224  LLVMPrivateLinkage,     /**< Like Internal, but omit from symbol table */
225  LLVMDLLImportLinkage,   /**< Function to be imported from DLL */
226  LLVMDLLExportLinkage,   /**< Function to be accessible from DLL */
227  LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
228  LLVMGhostLinkage,       /**< Obsolete */
229  LLVMCommonLinkage,      /**< Tentative definitions */
230  LLVMLinkerPrivateLinkage /**< Like Private, but linker removes. */
231} LLVMLinkage;
232
233typedef enum {
234  LLVMDefaultVisibility,  /**< The GV is visible */
235  LLVMHiddenVisibility,   /**< The GV is hidden */
236  LLVMProtectedVisibility /**< The GV is protected */
237} LLVMVisibility;
238
239typedef enum {
240  LLVMCCallConv           = 0,
241  LLVMFastCallConv        = 8,
242  LLVMColdCallConv        = 9,
243  LLVMX86StdcallCallConv  = 64,
244  LLVMX86FastcallCallConv = 65
245} LLVMCallConv;
246
247typedef enum {
248  LLVMIntEQ = 32, /**< equal */
249  LLVMIntNE,      /**< not equal */
250  LLVMIntUGT,     /**< unsigned greater than */
251  LLVMIntUGE,     /**< unsigned greater or equal */
252  LLVMIntULT,     /**< unsigned less than */
253  LLVMIntULE,     /**< unsigned less or equal */
254  LLVMIntSGT,     /**< signed greater than */
255  LLVMIntSGE,     /**< signed greater or equal */
256  LLVMIntSLT,     /**< signed less than */
257  LLVMIntSLE      /**< signed less or equal */
258} LLVMIntPredicate;
259
260typedef enum {
261  LLVMRealPredicateFalse, /**< Always false (always folded) */
262  LLVMRealOEQ,            /**< True if ordered and equal */
263  LLVMRealOGT,            /**< True if ordered and greater than */
264  LLVMRealOGE,            /**< True if ordered and greater than or equal */
265  LLVMRealOLT,            /**< True if ordered and less than */
266  LLVMRealOLE,            /**< True if ordered and less than or equal */
267  LLVMRealONE,            /**< True if ordered and operands are unequal */
268  LLVMRealORD,            /**< True if ordered (no nans) */
269  LLVMRealUNO,            /**< True if unordered: isnan(X) | isnan(Y) */
270  LLVMRealUEQ,            /**< True if unordered or equal */
271  LLVMRealUGT,            /**< True if unordered or greater than */
272  LLVMRealUGE,            /**< True if unordered, greater than, or equal */
273  LLVMRealULT,            /**< True if unordered or less than */
274  LLVMRealULE,            /**< True if unordered, less than, or equal */
275  LLVMRealUNE,            /**< True if unordered or not equal */
276  LLVMRealPredicateTrue   /**< Always true (always folded) */
277} LLVMRealPredicate;
278
279
280/*===-- Error handling ----------------------------------------------------===*/
281
282void LLVMDisposeMessage(char *Message);
283
284
285/*===-- Modules -----------------------------------------------------------===*/
286
287/* Create and destroy contexts. */
288LLVMContextRef LLVMContextCreate(void);
289LLVMContextRef LLVMGetGlobalContext(void);
290void LLVMContextDispose(LLVMContextRef C);
291
292/* Create and destroy modules. */
293/** See llvm::Module::Module. */
294LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
295LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
296                                                LLVMContextRef C);
297
298/** See llvm::Module::~Module. */
299void LLVMDisposeModule(LLVMModuleRef M);
300
301/** Data layout. See Module::getDataLayout. */
302const char *LLVMGetDataLayout(LLVMModuleRef M);
303void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple);
304
305/** Target triple. See Module::getTargetTriple. */
306const char *LLVMGetTarget(LLVMModuleRef M);
307void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
308
309/** See Module::addTypeName. */
310LLVMBool LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
311void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
312LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name);
313
314/** See Module::dump. */
315void LLVMDumpModule(LLVMModuleRef M);
316
317
318/*===-- Types -------------------------------------------------------------===*/
319
320/* LLVM types conform to the following hierarchy:
321 *
322 *   types:
323 *     integer type
324 *     real type
325 *     function type
326 *     sequence types:
327 *       array type
328 *       pointer type
329 *       vector type
330 *     void type
331 *     label type
332 *     opaque type
333 */
334
335/** See llvm::LLVMTypeKind::getTypeID. */
336LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
337
338/** See llvm::LLVMType::getContext. */
339LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty);
340
341/* Operations on integer types */
342LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C);
343LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C);
344LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C);
345LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C);
346LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C);
347LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits);
348
349LLVMTypeRef LLVMInt1Type(void);
350LLVMTypeRef LLVMInt8Type(void);
351LLVMTypeRef LLVMInt16Type(void);
352LLVMTypeRef LLVMInt32Type(void);
353LLVMTypeRef LLVMInt64Type(void);
354LLVMTypeRef LLVMIntType(unsigned NumBits);
355unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
356
357/* Operations on real types */
358LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C);
359LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C);
360LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C);
361LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C);
362LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C);
363
364LLVMTypeRef LLVMFloatType(void);
365LLVMTypeRef LLVMDoubleType(void);
366LLVMTypeRef LLVMX86FP80Type(void);
367LLVMTypeRef LLVMFP128Type(void);
368LLVMTypeRef LLVMPPCFP128Type(void);
369
370/* Operations on function types */
371LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
372                             LLVMTypeRef *ParamTypes, unsigned ParamCount,
373                             LLVMBool IsVarArg);
374LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
375LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
376unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
377void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
378
379/* Operations on struct types */
380LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
381                                    unsigned ElementCount, LLVMBool Packed);
382LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
383                           LLVMBool Packed);
384unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
385void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
386LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy);
387
388/* Operations on union types */
389LLVMTypeRef LLVMUnionTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
390                                   unsigned ElementCount);
391LLVMTypeRef LLVMUnionType(LLVMTypeRef *ElementTypes, unsigned ElementCount);
392unsigned LLVMCountUnionElementTypes(LLVMTypeRef UnionTy);
393void LLVMGetUnionElementTypes(LLVMTypeRef UnionTy, LLVMTypeRef *Dest);
394
395/* Operations on array, pointer, and vector types (sequence types) */
396LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
397LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
398LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
399
400LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
401unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
402unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
403unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
404
405/* Operations on other types */
406LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C);
407LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C);
408LLVMTypeRef LLVMOpaqueTypeInContext(LLVMContextRef C);
409
410LLVMTypeRef LLVMVoidType(void);
411LLVMTypeRef LLVMLabelType(void);
412LLVMTypeRef LLVMOpaqueType(void);
413
414/* Operations on type handles */
415LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
416void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
417LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
418void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
419
420
421/*===-- Values ------------------------------------------------------------===*/
422
423/* The bulk of LLVM's object model consists of values, which comprise a very
424 * rich type hierarchy.
425 */
426
427#define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \
428  macro(Argument)                           \
429  macro(BasicBlock)                         \
430  macro(InlineAsm)                          \
431  macro(User)                               \
432    macro(Constant)                         \
433      macro(ConstantAggregateZero)          \
434      macro(ConstantArray)                  \
435      macro(ConstantExpr)                   \
436      macro(ConstantFP)                     \
437      macro(ConstantInt)                    \
438      macro(ConstantPointerNull)            \
439      macro(ConstantStruct)                 \
440      macro(ConstantVector)                 \
441      macro(GlobalValue)                    \
442        macro(Function)                     \
443        macro(GlobalAlias)                  \
444        macro(GlobalVariable)               \
445      macro(UndefValue)                     \
446    macro(Instruction)                      \
447      macro(BinaryOperator)                 \
448      macro(CallInst)                       \
449        macro(IntrinsicInst)                \
450          macro(DbgInfoIntrinsic)           \
451            macro(DbgDeclareInst)           \
452          macro(EHSelectorInst)             \
453          macro(MemIntrinsic)               \
454            macro(MemCpyInst)               \
455            macro(MemMoveInst)              \
456            macro(MemSetInst)               \
457      macro(CmpInst)                        \
458      macro(FCmpInst)                       \
459      macro(ICmpInst)                       \
460      macro(ExtractElementInst)             \
461      macro(GetElementPtrInst)              \
462      macro(InsertElementInst)              \
463      macro(InsertValueInst)                \
464      macro(PHINode)                        \
465      macro(SelectInst)                     \
466      macro(ShuffleVectorInst)              \
467      macro(StoreInst)                      \
468      macro(TerminatorInst)                 \
469        macro(BranchInst)                   \
470        macro(InvokeInst)                   \
471        macro(ReturnInst)                   \
472        macro(SwitchInst)                   \
473        macro(UnreachableInst)              \
474        macro(UnwindInst)                   \
475    macro(UnaryInstruction)                 \
476      macro(AllocaInst)                     \
477      macro(CastInst)                       \
478        macro(BitCastInst)                  \
479        macro(FPExtInst)                    \
480        macro(FPToSIInst)                   \
481        macro(FPToUIInst)                   \
482        macro(FPTruncInst)                  \
483        macro(IntToPtrInst)                 \
484        macro(PtrToIntInst)                 \
485        macro(SExtInst)                     \
486        macro(SIToFPInst)                   \
487        macro(TruncInst)                    \
488        macro(UIToFPInst)                   \
489        macro(ZExtInst)                     \
490      macro(ExtractValueInst)               \
491      macro(LoadInst)                       \
492      macro(VAArgInst)
493
494/* Operations on all values */
495LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
496const char *LLVMGetValueName(LLVMValueRef Val);
497void LLVMSetValueName(LLVMValueRef Val, const char *Name);
498void LLVMDumpValue(LLVMValueRef Val);
499void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
500
501/* Conversion functions. Return the input value if it is an instance of the
502   specified class, otherwise NULL. See llvm::dyn_cast_or_null<>. */
503#define LLVM_DECLARE_VALUE_CAST(name) \
504  LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
505LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST)
506
507/* Operations on Uses */
508LLVMUseIteratorRef LLVMGetFirstUse(LLVMValueRef Val);
509LLVMUseIteratorRef LLVMGetNextUse(LLVMUseIteratorRef U);
510LLVMValueRef LLVMGetUser(LLVMUseIteratorRef U);
511LLVMValueRef LLVMGetUsedValue(LLVMUseIteratorRef U);
512
513/* Operations on Users */
514LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index);
515
516/* Operations on constants of any type */
517LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
518LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
519LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
520LLVMBool LLVMIsConstant(LLVMValueRef Val);
521LLVMBool LLVMIsNull(LLVMValueRef Val);
522LLVMBool LLVMIsUndef(LLVMValueRef Val);
523LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
524
525/* Operations on scalar constants */
526LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
527                          LLVMBool SignExtend);
528LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text,
529                                  uint8_t Radix);
530LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text,
531                                         unsigned SLen, uint8_t Radix);
532LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
533LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
534LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text,
535                                          unsigned SLen);
536unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal);
537long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal);
538
539
540/* Operations on composite constants */
541LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
542                                      unsigned Length, LLVMBool DontNullTerminate);
543LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
544                                      LLVMValueRef *ConstantVals,
545                                      unsigned Count, LLVMBool Packed);
546
547LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
548                             LLVMBool DontNullTerminate);
549LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
550                            LLVMValueRef *ConstantVals, unsigned Length);
551LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
552                             LLVMBool Packed);
553LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
554
555/* Constant expressions */
556LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal);
557LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty);
558LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
559LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
560LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal);
561LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
562LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
563LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
564LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
565LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
566LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
567LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
568LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
569LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
570LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
571LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
572LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
573LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
574LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
575LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
576LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
577LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
578LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
579LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
580                           LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
581LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
582                           LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
583LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
584LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
585LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
586LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
587                          LLVMValueRef *ConstantIndices, unsigned NumIndices);
588LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
589                                  LLVMValueRef *ConstantIndices,
590                                  unsigned NumIndices);
591LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
592LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
593LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
594LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
595LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
596LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
597LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
598LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
599LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
600LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
601LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
602LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
603LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,
604                                    LLVMTypeRef ToType);
605LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,
606                                    LLVMTypeRef ToType);
607LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,
608                                     LLVMTypeRef ToType);
609LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal,
610                                  LLVMTypeRef ToType);
611LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType,
612                              LLVMBool isSigned);
613LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
614LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
615                             LLVMValueRef ConstantIfTrue,
616                             LLVMValueRef ConstantIfFalse);
617LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
618                                     LLVMValueRef IndexConstant);
619LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
620                                    LLVMValueRef ElementValueConstant,
621                                    LLVMValueRef IndexConstant);
622LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
623                                    LLVMValueRef VectorBConstant,
624                                    LLVMValueRef MaskConstant);
625LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
626                                   unsigned NumIdx);
627LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
628                                  LLVMValueRef ElementValueConstant,
629                                  unsigned *IdxList, unsigned NumIdx);
630LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty,
631                                const char *AsmString, const char *Constraints,
632                                LLVMBool HasSideEffects, LLVMBool IsAlignStack);
633
634/* Operations on global variables, functions, and aliases (globals) */
635LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
636LLVMBool LLVMIsDeclaration(LLVMValueRef Global);
637LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
638void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
639const char *LLVMGetSection(LLVMValueRef Global);
640void LLVMSetSection(LLVMValueRef Global, const char *Section);
641LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
642void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
643unsigned LLVMGetAlignment(LLVMValueRef Global);
644void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
645
646/* Operations on global variables */
647LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
648LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
649LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
650LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
651LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
652LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
653void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
654LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
655void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
656LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar);
657void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal);
658LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
659void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant);
660
661/* Operations on aliases */
662LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
663                          const char *Name);
664
665/* Operations on functions */
666LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
667                             LLVMTypeRef FunctionTy);
668LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
669LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
670LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
671LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
672LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
673void LLVMDeleteFunction(LLVMValueRef Fn);
674unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
675unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
676void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
677const char *LLVMGetGC(LLVMValueRef Fn);
678void LLVMSetGC(LLVMValueRef Fn, const char *Name);
679void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
680LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn);
681void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
682
683/* Operations on parameters */
684unsigned LLVMCountParams(LLVMValueRef Fn);
685void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
686LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
687LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
688LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
689LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
690LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
691LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
692void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA);
693void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA);
694LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg);
695void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align);
696
697/* Operations on basic blocks */
698LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
699LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val);
700LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
701LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
702unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
703void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
704LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
705LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
706LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
707LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
708LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
709
710LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
711                                                LLVMValueRef Fn,
712                                                const char *Name);
713LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
714                                                LLVMBasicBlockRef BB,
715                                                const char *Name);
716
717LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
718LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
719                                       const char *Name);
720void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
721
722/* Operations on instructions */
723LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
724LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
725LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
726LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
727LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
728
729/* Operations on call sites */
730void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
731unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
732void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
733void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
734                              LLVMAttribute);
735void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
736                                unsigned align);
737
738/* Operations on call instructions (only) */
739LLVMBool LLVMIsTailCall(LLVMValueRef CallInst);
740void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall);
741
742/* Operations on phi nodes */
743void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
744                     LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
745unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
746LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
747LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
748
749/*===-- Instruction builders ----------------------------------------------===*/
750
751/* An instruction builder represents a point within a basic block, and is the
752 * exclusive means of building instructions using the C interface.
753 */
754
755LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
756LLVMBuilderRef LLVMCreateBuilder(void);
757void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
758                         LLVMValueRef Instr);
759void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
760void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
761LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
762void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
763void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
764void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
765                                   const char *Name);
766void LLVMDisposeBuilder(LLVMBuilderRef Builder);
767
768/* Terminators */
769LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
770LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
771LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
772                                   unsigned N);
773LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
774LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
775                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
776LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
777                             LLVMBasicBlockRef Else, unsigned NumCases);
778LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
779                             LLVMValueRef *Args, unsigned NumArgs,
780                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
781                             const char *Name);
782LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
783LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
784
785/* Add a case to the switch instruction */
786void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
787                 LLVMBasicBlockRef Dest);
788
789/* Arithmetic */
790LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
791                          const char *Name);
792LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
793                             const char *Name);
794LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
795                           const char *Name);
796LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
797                          const char *Name);
798LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
799                           const char *Name);
800LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
801                          const char *Name);
802LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
803                           const char *Name);
804LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
805                           const char *Name);
806LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
807                           const char *Name);
808LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
809                                const char *Name);
810LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
811                           const char *Name);
812LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
813                           const char *Name);
814LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
815                           const char *Name);
816LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
817                           const char *Name);
818LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
819                           const char *Name);
820LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
821                           const char *Name);
822LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
823                           const char *Name);
824LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
825                          const char *Name);
826LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
827                          const char *Name);
828LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
829                          const char *Name);
830LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
831LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
832LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
833
834/* Memory */
835LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
836LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
837                                  LLVMValueRef Val, const char *Name);
838LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
839LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
840                                  LLVMValueRef Val, const char *Name);
841LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
842LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
843                           const char *Name);
844LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
845LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
846                          LLVMValueRef *Indices, unsigned NumIndices,
847                          const char *Name);
848LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
849                                  LLVMValueRef *Indices, unsigned NumIndices,
850                                  const char *Name);
851LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
852                                unsigned Idx, const char *Name);
853LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
854                                   const char *Name);
855LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
856                                      const char *Name);
857
858/* Casts */
859LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
860                            LLVMTypeRef DestTy, const char *Name);
861LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
862                           LLVMTypeRef DestTy, const char *Name);
863LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
864                           LLVMTypeRef DestTy, const char *Name);
865LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
866                             LLVMTypeRef DestTy, const char *Name);
867LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
868                             LLVMTypeRef DestTy, const char *Name);
869LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
870                             LLVMTypeRef DestTy, const char *Name);
871LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
872                             LLVMTypeRef DestTy, const char *Name);
873LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
874                              LLVMTypeRef DestTy, const char *Name);
875LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
876                            LLVMTypeRef DestTy, const char *Name);
877LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
878                               LLVMTypeRef DestTy, const char *Name);
879LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
880                               LLVMTypeRef DestTy, const char *Name);
881LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
882                              LLVMTypeRef DestTy, const char *Name);
883LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
884                                    LLVMTypeRef DestTy, const char *Name);
885LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
886                                    LLVMTypeRef DestTy, const char *Name);
887LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
888                                     LLVMTypeRef DestTy, const char *Name);
889LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
890                                  LLVMTypeRef DestTy, const char *Name);
891LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/
892                              LLVMTypeRef DestTy, const char *Name);
893LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
894                             LLVMTypeRef DestTy, const char *Name);
895
896/* Comparisons */
897LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
898                           LLVMValueRef LHS, LLVMValueRef RHS,
899                           const char *Name);
900LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
901                           LLVMValueRef LHS, LLVMValueRef RHS,
902                           const char *Name);
903
904/* Miscellaneous instructions */
905LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
906LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
907                           LLVMValueRef *Args, unsigned NumArgs,
908                           const char *Name);
909LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
910                             LLVMValueRef Then, LLVMValueRef Else,
911                             const char *Name);
912LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
913                            const char *Name);
914LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
915                                     LLVMValueRef Index, const char *Name);
916LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
917                                    LLVMValueRef EltVal, LLVMValueRef Index,
918                                    const char *Name);
919LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
920                                    LLVMValueRef V2, LLVMValueRef Mask,
921                                    const char *Name);
922LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
923                                   unsigned Index, const char *Name);
924LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
925                                  LLVMValueRef EltVal, unsigned Index,
926                                  const char *Name);
927
928LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
929                             const char *Name);
930LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
931                                const char *Name);
932LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
933                              LLVMValueRef RHS, const char *Name);
934
935
936/*===-- Module providers --------------------------------------------------===*/
937
938/* Changes the type of M so it can be passed to FunctionPassManagers and the
939 * JIT.  They take ModuleProviders for historical reasons.
940 */
941LLVMModuleProviderRef
942LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
943
944/* Destroys the module M.
945 */
946void LLVMDisposeModuleProvider(LLVMModuleProviderRef M);
947
948
949/*===-- Memory buffers ----------------------------------------------------===*/
950
951LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
952                                                  LLVMMemoryBufferRef *OutMemBuf,
953                                                  char **OutMessage);
954LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
955                                         char **OutMessage);
956void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
957
958
959/*===-- Pass Managers -----------------------------------------------------===*/
960
961/** Constructs a new whole-module pass pipeline. This type of pipeline is
962    suitable for link-time optimization and whole-module transformations.
963    See llvm::PassManager::PassManager. */
964LLVMPassManagerRef LLVMCreatePassManager(void);
965
966/** Constructs a new function-by-function pass pipeline over the module
967    provider. It does not take ownership of the module provider. This type of
968    pipeline is suitable for code generation and JIT compilation tasks.
969    See llvm::FunctionPassManager::FunctionPassManager. */
970LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
971
972/** Initializes, executes on the provided module, and finalizes all of the
973    passes scheduled in the pass manager. Returns 1 if any of the passes
974    modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */
975LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
976
977/** Initializes all of the function passes scheduled in the function pass
978    manager. Returns 1 if any of the passes modified the module, 0 otherwise.
979    See llvm::FunctionPassManager::doInitialization. */
980LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
981
982/** Executes all of the function passes scheduled in the function pass manager
983    on the provided function. Returns 1 if any of the passes modified the
984    function, false otherwise.
985    See llvm::FunctionPassManager::run(Function&). */
986LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
987
988/** Finalizes all of the function passes scheduled in in the function pass
989    manager. Returns 1 if any of the passes modified the module, 0 otherwise.
990    See llvm::FunctionPassManager::doFinalization. */
991LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
992
993/** Frees the memory of a pass pipeline. For function pipelines, does not free
994    the module provider.
995    See llvm::PassManagerBase::~PassManagerBase. */
996void LLVMDisposePassManager(LLVMPassManagerRef PM);
997
998
999#ifdef __cplusplus
1000}
1001
1002namespace llvm {
1003  class MemoryBuffer;
1004  class PassManagerBase;
1005
1006  #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)   \
1007    inline ty *unwrap(ref P) {                          \
1008      return reinterpret_cast<ty*>(P);                  \
1009    }                                                   \
1010                                                        \
1011    inline ref wrap(const ty *P) {                      \
1012      return reinterpret_cast<ref>(const_cast<ty*>(P)); \
1013    }
1014
1015  #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref)  \
1016    DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)         \
1017                                                        \
1018    template<typename T>                                \
1019    inline T *unwrap(ref P) {                           \
1020      return cast<T>(unwrap(P));                        \
1021    }
1022
1023  #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref)   \
1024    DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)         \
1025                                                        \
1026    template<typename T>                                \
1027    inline T *unwrap(ref P) {                           \
1028      T *Q = (T*)unwrap(P);                             \
1029      assert(Q && "Invalid cast!");                     \
1030      return Q;                                         \
1031    }
1032
1033  DEFINE_ISA_CONVERSION_FUNCTIONS   (Type,               LLVMTypeRef          )
1034  DEFINE_ISA_CONVERSION_FUNCTIONS   (Value,              LLVMValueRef         )
1035  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module,             LLVMModuleRef        )
1036  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock,         LLVMBasicBlockRef    )
1037  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>,        LLVMBuilderRef       )
1038  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder,       LLVMTypeHandleRef    )
1039  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer,       LLVMMemoryBufferRef  )
1040  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext,        LLVMContextRef       )
1041  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Use,                LLVMUseIteratorRef           )
1042  DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase,    LLVMPassManagerRef   )
1043  /* LLVMModuleProviderRef exists for historical reasons, but now just holds a
1044   * Module.
1045   */
1046  inline Module *unwrap(LLVMModuleProviderRef MP) {
1047    return reinterpret_cast<Module*>(MP);
1048  }
1049
1050  #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS
1051  #undef DEFINE_ISA_CONVERSION_FUNCTIONS
1052  #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
1053
1054  /* Specialized opaque context conversions.
1055   */
1056  inline LLVMContext **unwrap(LLVMContextRef* Tys) {
1057    return reinterpret_cast<LLVMContext**>(Tys);
1058  }
1059
1060  inline LLVMContextRef *wrap(const LLVMContext **Tys) {
1061    return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys));
1062  }
1063
1064  /* Specialized opaque type conversions.
1065   */
1066  inline Type **unwrap(LLVMTypeRef* Tys) {
1067    return reinterpret_cast<Type**>(Tys);
1068  }
1069
1070  inline LLVMTypeRef *wrap(const Type **Tys) {
1071    return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
1072  }
1073
1074  /* Specialized opaque value conversions.
1075   */
1076  inline Value **unwrap(LLVMValueRef *Vals) {
1077    return reinterpret_cast<Value**>(Vals);
1078  }
1079
1080  template<typename T>
1081  inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
1082    #if DEBUG
1083    for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
1084      cast<T>(*I);
1085    #endif
1086    return reinterpret_cast<T**>(Vals);
1087  }
1088
1089  inline LLVMValueRef *wrap(const Value **Vals) {
1090    return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
1091  }
1092}
1093
1094#endif /* !defined(__cplusplus) */
1095
1096#endif /* !defined(LLVM_C_CORE_H) */
1097