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