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