Core.h revision 613d13beb03bb56a17e6b3262c5e8e539a7e9db8 
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);
747unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
748void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
749LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
750LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
751LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
752LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
753LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
754
755LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
756                                                LLVMValueRef Fn,
757                                                const char *Name);
758LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
759                                                LLVMBasicBlockRef BB,
760                                                const char *Name);
761
762LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
763LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
764                                       const char *Name);
765void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
766
767void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
768void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
769
770/* Operations on instructions */
771LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
772LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
773LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
774LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
775LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
776
777/* Operations on call sites */
778void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
779unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
780void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
781void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
782                              LLVMAttribute);
783void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
784                                unsigned align);
785
786/* Operations on call instructions (only) */
787LLVMBool LLVMIsTailCall(LLVMValueRef CallInst);
788void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall);
789
790/* Operations on phi nodes */
791void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
792                     LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
793unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
794LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
795LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
796
797/*===-- Instruction builders ----------------------------------------------===*/
798
799/* An instruction builder represents a point within a basic block, and is the
800 * exclusive means of building instructions using the C interface.
801 */
802
803LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
804LLVMBuilderRef LLVMCreateBuilder(void);
805void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
806                         LLVMValueRef Instr);
807void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
808void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
809LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
810void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
811void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
812void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
813                                   const char *Name);
814void LLVMDisposeBuilder(LLVMBuilderRef Builder);
815
816/* Metadata */
817void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L);
818LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder);
819void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst);
820
821/* Terminators */
822LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
823LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
824LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
825                                   unsigned N);
826LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
827LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
828                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
829LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
830                             LLVMBasicBlockRef Else, unsigned NumCases);
831LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
832                                 unsigned NumDests);
833LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
834                             LLVMValueRef *Args, unsigned NumArgs,
835                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
836                             const char *Name);
837LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
838                                 LLVMValueRef PersFn, unsigned NumClauses,
839                                 const char *Name);
840LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn);
841LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
842
843/* Add a case to the switch instruction */
844void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
845                 LLVMBasicBlockRef Dest);
846
847/* Add a destination to the indirectbr instruction */
848void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest);
849
850/* Add a catch or filter clause to the landingpad instruction */
851void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal);
852
853/* Set the 'cleanup' flag in the landingpad instruction */
854void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val);
855
856/* Arithmetic */
857LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
858                          const char *Name);
859LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
860                             const char *Name);
861LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
862                             const char *Name);
863LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
864                           const char *Name);
865LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
866                          const char *Name);
867LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
868                             const char *Name);
869LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
870                             const char *Name);
871LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
872                           const char *Name);
873LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
874                          const char *Name);
875LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
876                             const char *Name);
877LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
878                             const char *Name);
879LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
880                           const char *Name);
881LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
882                           const char *Name);
883LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
884                           const char *Name);
885LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
886                                const char *Name);
887LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
888                           const char *Name);
889LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
890                           const char *Name);
891LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
892                           const char *Name);
893LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
894                           const char *Name);
895LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
896                           const char *Name);
897LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
898                           const char *Name);
899LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
900                           const char *Name);
901LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
902                          const char *Name);
903LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
904                          const char *Name);
905LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
906                          const char *Name);
907LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
908                            LLVMValueRef LHS, LLVMValueRef RHS,
909                            const char *Name);
910LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
911LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
912                             const char *Name);
913LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
914                             const char *Name);
915LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
916LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
917
918/* Memory */
919LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
920LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
921                                  LLVMValueRef Val, const char *Name);
922LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
923LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
924                                  LLVMValueRef Val, const char *Name);
925LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
926LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
927                           const char *Name);
928LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
929LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
930                          LLVMValueRef *Indices, unsigned NumIndices,
931                          const char *Name);
932LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
933                                  LLVMValueRef *Indices, unsigned NumIndices,
934                                  const char *Name);
935LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
936                                unsigned Idx, const char *Name);
937LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
938                                   const char *Name);
939LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
940                                      const char *Name);
941
942/* Casts */
943LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
944                            LLVMTypeRef DestTy, const char *Name);
945LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
946                           LLVMTypeRef DestTy, const char *Name);
947LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
948                           LLVMTypeRef DestTy, const char *Name);
949LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
950                             LLVMTypeRef DestTy, const char *Name);
951LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
952                             LLVMTypeRef DestTy, const char *Name);
953LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
954                             LLVMTypeRef DestTy, const char *Name);
955LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
956                             LLVMTypeRef DestTy, const char *Name);
957LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
958                              LLVMTypeRef DestTy, const char *Name);
959LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
960                            LLVMTypeRef DestTy, const char *Name);
961LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
962                               LLVMTypeRef DestTy, const char *Name);
963LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
964                               LLVMTypeRef DestTy, const char *Name);
965LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
966                              LLVMTypeRef DestTy, const char *Name);
967LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
968                                    LLVMTypeRef DestTy, const char *Name);
969LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
970                                    LLVMTypeRef DestTy, const char *Name);
971LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
972                                     LLVMTypeRef DestTy, const char *Name);
973LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
974                           LLVMTypeRef DestTy, const char *Name);
975LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
976                                  LLVMTypeRef DestTy, const char *Name);
977LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/
978                              LLVMTypeRef DestTy, const char *Name);
979LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
980                             LLVMTypeRef DestTy, const char *Name);
981
982/* Comparisons */
983LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
984                           LLVMValueRef LHS, LLVMValueRef RHS,
985                           const char *Name);
986LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
987                           LLVMValueRef LHS, LLVMValueRef RHS,
988                           const char *Name);
989
990/* Miscellaneous instructions */
991LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
992LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
993                           LLVMValueRef *Args, unsigned NumArgs,
994                           const char *Name);
995LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
996                             LLVMValueRef Then, LLVMValueRef Else,
997                             const char *Name);
998LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
999                            const char *Name);
1000LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
1001                                     LLVMValueRef Index, const char *Name);
1002LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
1003                                    LLVMValueRef EltVal, LLVMValueRef Index,
1004                                    const char *Name);
1005LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
1006                                    LLVMValueRef V2, LLVMValueRef Mask,
1007                                    const char *Name);
1008LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
1009                                   unsigned Index, const char *Name);
1010LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
1011                                  LLVMValueRef EltVal, unsigned Index,
1012                                  const char *Name);
1013
1014LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
1015                             const char *Name);
1016LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
1017                                const char *Name);
1018LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
1019                              LLVMValueRef RHS, const char *Name);
1020
1021
1022/*===-- Module providers --------------------------------------------------===*/
1023
1024/* Changes the type of M so it can be passed to FunctionPassManagers and the
1025 * JIT.  They take ModuleProviders for historical reasons.
1026 */
1027LLVMModuleProviderRef
1028LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
1029
1030/* Destroys the module M.
1031 */
1032void LLVMDisposeModuleProvider(LLVMModuleProviderRef M);
1033
1034
1035/*===-- Memory buffers ----------------------------------------------------===*/
1036
1037LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
1038                                                  LLVMMemoryBufferRef *OutMemBuf,
1039                                                  char **OutMessage);
1040LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
1041                                         char **OutMessage);
1042void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
1043
1044/*===-- Pass Registry -----------------------------------------------------===*/
1045
1046/** Return the global pass registry, for use with initialization functions.
1047    See llvm::PassRegistry::getPassRegistry. */
1048LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void);
1049
1050/*===-- Pass Managers -----------------------------------------------------===*/
1051
1052/** Constructs a new whole-module pass pipeline. This type of pipeline is
1053    suitable for link-time optimization and whole-module transformations.
1054    See llvm::PassManager::PassManager. */
1055LLVMPassManagerRef LLVMCreatePassManager(void);
1056
1057/** Constructs a new function-by-function pass pipeline over the module
1058    provider. It does not take ownership of the module provider. This type of
1059    pipeline is suitable for code generation and JIT compilation tasks.
1060    See llvm::FunctionPassManager::FunctionPassManager. */
1061LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M);
1062
1063/** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */
1064LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
1065
1066/** Initializes, executes on the provided module, and finalizes all of the
1067    passes scheduled in the pass manager. Returns 1 if any of the passes
1068    modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */
1069LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
1070
1071/** Initializes all of the function passes scheduled in the function pass
1072    manager. Returns 1 if any of the passes modified the module, 0 otherwise.
1073    See llvm::FunctionPassManager::doInitialization. */
1074LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
1075
1076/** Executes all of the function passes scheduled in the function pass manager
1077    on the provided function. Returns 1 if any of the passes modified the
1078    function, false otherwise.
1079    See llvm::FunctionPassManager::run(Function&). */
1080LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
1081
1082/** Finalizes all of the function passes scheduled in in the function pass
1083    manager. Returns 1 if any of the passes modified the module, 0 otherwise.
1084    See llvm::FunctionPassManager::doFinalization. */
1085LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
1086
1087/** Frees the memory of a pass pipeline. For function pipelines, does not free
1088    the module provider.
1089    See llvm::PassManagerBase::~PassManagerBase. */
1090void LLVMDisposePassManager(LLVMPassManagerRef PM);
1091
1092
1093#ifdef __cplusplus
1094}
1095
1096namespace llvm {
1097  class MemoryBuffer;
1098  class PassManagerBase;
1099
1100  #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)   \
1101    inline ty *unwrap(ref P) {                          \
1102      return reinterpret_cast<ty*>(P);                  \
1103    }                                                   \
1104                                                        \
1105    inline ref wrap(const ty *P) {                      \
1106      return reinterpret_cast<ref>(const_cast<ty*>(P)); \
1107    }
1108
1109  #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref)  \
1110    DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)         \
1111                                                        \
1112    template<typename T>                                \
1113    inline T *unwrap(ref P) {                           \
1114      return cast<T>(unwrap(P));                        \
1115    }
1116
1117  #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref)   \
1118    DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)         \
1119                                                        \
1120    template<typename T>                                \
1121    inline T *unwrap(ref P) {                           \
1122      T *Q = (T*)unwrap(P);                             \
1123      assert(Q && "Invalid cast!");                     \
1124      return Q;                                         \
1125    }
1126
1127  DEFINE_ISA_CONVERSION_FUNCTIONS   (Type,               LLVMTypeRef          )
1128  DEFINE_ISA_CONVERSION_FUNCTIONS   (Value,              LLVMValueRef         )
1129  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module,             LLVMModuleRef        )
1130  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock,         LLVMBasicBlockRef    )
1131  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>,        LLVMBuilderRef       )
1132  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer,       LLVMMemoryBufferRef  )
1133  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext,        LLVMContextRef       )
1134  DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Use,                LLVMUseRef           )
1135  DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase,    LLVMPassManagerRef   )
1136  DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassRegistry,       LLVMPassRegistryRef  )
1137  /* LLVMModuleProviderRef exists for historical reasons, but now just holds a
1138   * Module.
1139   */
1140  inline Module *unwrap(LLVMModuleProviderRef MP) {
1141    return reinterpret_cast<Module*>(MP);
1142  }
1143
1144  #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS
1145  #undef DEFINE_ISA_CONVERSION_FUNCTIONS
1146  #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
1147
1148  /* Specialized opaque context conversions.
1149   */
1150  inline LLVMContext **unwrap(LLVMContextRef* Tys) {
1151    return reinterpret_cast<LLVMContext**>(Tys);
1152  }
1153
1154  inline LLVMContextRef *wrap(const LLVMContext **Tys) {
1155    return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys));
1156  }
1157
1158  /* Specialized opaque type conversions.
1159   */
1160  inline Type **unwrap(LLVMTypeRef* Tys) {
1161    return reinterpret_cast<Type**>(Tys);
1162  }
1163
1164  inline LLVMTypeRef *wrap(Type **Tys) {
1165    return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
1166  }
1167
1168  /* Specialized opaque value conversions.
1169   */
1170  inline Value **unwrap(LLVMValueRef *Vals) {
1171    return reinterpret_cast<Value**>(Vals);
1172  }
1173
1174  template<typename T>
1175  inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
1176    #if DEBUG
1177    for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
1178      cast<T>(*I);
1179    #endif
1180    (void)Length;
1181    return reinterpret_cast<T**>(Vals);
1182  }
1183
1184  inline LLVMValueRef *wrap(const Value **Vals) {
1185    return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
1186  }
1187}
1188
1189#endif /* !defined(__cplusplus) */
1190
1191#endif /* !defined(LLVM_C_CORE_H) */
1192