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