1 /*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
3 |* The LLVM Compiler Infrastructure *|
5 |* This file is distributed under the University of Illinois Open Source *|
6 |* License. See LICENSE.TXT for details. *|
8 |*===----------------------------------------------------------------------===*|
10 |* This header declares the C interface to libLLVMCore.a, which implements *|
11 |* the LLVM intermediate representation. *|
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). *|
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. *|
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. *|
31 \*===----------------------------------------------------------------------===*/
36 #include "llvm/Support/DataTypes.h"
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"
52 * The top-level container for all LLVM global data. See the LLVMContext class.
54 typedef struct LLVMOpaqueContext *LLVMContextRef;
57 * The top-level container for all other LLVM Intermediate Representation (IR)
58 * objects. See the llvm::Module class.
60 typedef struct LLVMOpaqueModule *LLVMModuleRef;
63 * Each value in the LLVM IR has a type, an LLVMTypeRef. See the llvm::Type
66 typedef struct LLVMOpaqueType *LLVMTypeRef;
69 * When building recursive types using LLVMRefineType, LLVMTypeRef values may
70 * become invalid; use LLVMTypeHandleRef to resolve this problem. See the
71 * llvm::AbstractTypeHolder class.
73 typedef struct LLVMOpaqueTypeHandle *LLVMTypeHandleRef;
75 typedef struct LLVMOpaqueValue *LLVMValueRef;
76 typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
77 typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
79 /* Used to provide a module to JIT or interpreter.
80 * See the llvm::ModuleProvider class.
82 typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
84 /* Used to provide a module to JIT or interpreter.
85 * See the llvm::MemoryBuffer class.
87 typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef;
89 /** See the llvm::PassManagerBase class. */
90 typedef struct LLVMOpaquePassManager *LLVMPassManagerRef;
93 LLVMZExtAttribute = 1<<0,
94 LLVMSExtAttribute = 1<<1,
95 LLVMNoReturnAttribute = 1<<2,
96 LLVMInRegAttribute = 1<<3,
97 LLVMStructRetAttribute = 1<<4,
98 LLVMNoUnwindAttribute = 1<<5,
99 LLVMNoAliasAttribute = 1<<6,
100 LLVMByValAttribute = 1<<7,
101 LLVMNestAttribute = 1<<8,
102 LLVMReadNoneAttribute = 1<<9,
103 LLVMReadOnlyAttribute = 1<<10,
104 LLVMNoInlineAttribute = 1<<11,
105 LLVMAlwaysInlineAttribute = 1<<12,
106 LLVMOptimizeForSizeAttribute = 1<<13,
107 LLVMStackProtectAttribute = 1<<14,
108 LLVMStackProtectReqAttribute = 1<<15,
109 LLVMNoCaptureAttribute = 1<<21,
110 LLVMNoRedZoneAttribute = 1<<22,
111 LLVMNoImplicitFloatAttribute = 1<<23,
112 LLVMNakedAttribute = 1<<24
116 LLVMVoidTypeKind, /**< type with no size */
117 LLVMFloatTypeKind, /**< 32 bit floating point type */
118 LLVMDoubleTypeKind, /**< 64 bit floating point type */
119 LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */
120 LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/
121 LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */
122 LLVMLabelTypeKind, /**< Labels */
123 LLVMIntegerTypeKind, /**< Arbitrary bit width integers */
124 LLVMFunctionTypeKind, /**< Functions */
125 LLVMStructTypeKind, /**< Structures */
126 LLVMArrayTypeKind, /**< Arrays */
127 LLVMPointerTypeKind, /**< Pointers */
128 LLVMOpaqueTypeKind, /**< Opaque: type with unknown structure */
129 LLVMVectorTypeKind, /**< SIMD 'packed' format, or other vector type */
130 LLVMMetadataTypeKind /**< Metadata */
134 LLVMExternalLinkage, /**< Externally visible function */
135 LLVMAvailableExternallyLinkage,
136 LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
137 LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
139 LLVMWeakAnyLinkage, /**< Keep one copy of function when linking (weak) */
140 LLVMWeakODRLinkage, /**< Same, but only replaced by something
142 LLVMAppendingLinkage, /**< Special purpose, only applies to global arrays */
143 LLVMInternalLinkage, /**< Rename collisions when linking (static
145 LLVMPrivateLinkage, /**< Like Internal, but omit from symbol table */
146 LLVMDLLImportLinkage, /**< Function to be imported from DLL */
147 LLVMDLLExportLinkage, /**< Function to be accessible from DLL */
148 LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
149 LLVMGhostLinkage, /**< Stand-in functions for streaming fns from
151 LLVMCommonLinkage, /**< Tentative definitions */
152 LLVMLinkerPrivateLinkage /**< Like Private, but linker removes. */
156 LLVMDefaultVisibility, /**< The GV is visible */
157 LLVMHiddenVisibility, /**< The GV is hidden */
158 LLVMProtectedVisibility /**< The GV is protected */
163 LLVMFastCallConv = 8,
164 LLVMColdCallConv = 9,
165 LLVMX86StdcallCallConv = 64,
166 LLVMX86FastcallCallConv = 65
170 LLVMIntEQ = 32, /**< equal */
171 LLVMIntNE, /**< not equal */
172 LLVMIntUGT, /**< unsigned greater than */
173 LLVMIntUGE, /**< unsigned greater or equal */
174 LLVMIntULT, /**< unsigned less than */
175 LLVMIntULE, /**< unsigned less or equal */
176 LLVMIntSGT, /**< signed greater than */
177 LLVMIntSGE, /**< signed greater or equal */
178 LLVMIntSLT, /**< signed less than */
179 LLVMIntSLE /**< signed less or equal */
183 LLVMRealPredicateFalse, /**< Always false (always folded) */
184 LLVMRealOEQ, /**< True if ordered and equal */
185 LLVMRealOGT, /**< True if ordered and greater than */
186 LLVMRealOGE, /**< True if ordered and greater than or equal */
187 LLVMRealOLT, /**< True if ordered and less than */
188 LLVMRealOLE, /**< True if ordered and less than or equal */
189 LLVMRealONE, /**< True if ordered and operands are unequal */
190 LLVMRealORD, /**< True if ordered (no nans) */
191 LLVMRealUNO, /**< True if unordered: isnan(X) | isnan(Y) */
192 LLVMRealUEQ, /**< True if unordered or equal */
193 LLVMRealUGT, /**< True if unordered or greater than */
194 LLVMRealUGE, /**< True if unordered, greater than, or equal */
195 LLVMRealULT, /**< True if unordered or less than */
196 LLVMRealULE, /**< True if unordered, less than, or equal */
197 LLVMRealUNE, /**< True if unordered or not equal */
198 LLVMRealPredicateTrue /**< Always true (always folded) */
202 /*===-- Error handling ----------------------------------------------------===*/
204 void LLVMDisposeMessage(char *Message);
207 /*===-- Modules -----------------------------------------------------------===*/
209 /* Create and destroy contexts. */
210 LLVMContextRef LLVMContextCreate();
211 LLVMContextRef LLVMGetGlobalContext();
212 void LLVMContextDispose(LLVMContextRef C);
214 /* Create and destroy modules. */
215 /** See llvm::Module::Module. */
216 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
217 LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
220 /** See llvm::Module::~Module. */
221 void LLVMDisposeModule(LLVMModuleRef M);
223 /** Data layout. See Module::getDataLayout. */
224 const char *LLVMGetDataLayout(LLVMModuleRef M);
225 void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple);
227 /** Target triple. See Module::getTargetTriple. */
228 const char *LLVMGetTarget(LLVMModuleRef M);
229 void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
231 /** See Module::addTypeName. */
232 int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
233 void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
234 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name);
236 /** See Module::dump. */
237 void LLVMDumpModule(LLVMModuleRef M);
240 /*===-- Types -------------------------------------------------------------===*/
242 /* LLVM types conform to the following hierarchy:
257 /** See llvm::LLVMTypeKind::getTypeID. */
258 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
260 /** See llvm::LLVMType::getContext. */
261 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty);
263 /* Operations on integer types */
264 LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C);
265 LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C);
266 LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C);
267 LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C);
268 LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C);
269 LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits);
271 LLVMTypeRef LLVMInt1Type(void);
272 LLVMTypeRef LLVMInt8Type(void);
273 LLVMTypeRef LLVMInt16Type(void);
274 LLVMTypeRef LLVMInt32Type(void);
275 LLVMTypeRef LLVMInt64Type(void);
276 LLVMTypeRef LLVMIntType(unsigned NumBits);
277 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
279 /* Operations on real types */
280 LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C);
281 LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C);
282 LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C);
283 LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C);
284 LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C);
286 LLVMTypeRef LLVMFloatType(void);
287 LLVMTypeRef LLVMDoubleType(void);
288 LLVMTypeRef LLVMX86FP80Type(void);
289 LLVMTypeRef LLVMFP128Type(void);
290 LLVMTypeRef LLVMPPCFP128Type(void);
292 /* Operations on function types */
293 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
294 LLVMTypeRef *ParamTypes, unsigned ParamCount,
296 int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
297 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
298 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
299 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
301 /* Operations on struct types */
302 LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
303 unsigned ElementCount, int Packed);
304 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
306 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
307 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
308 int LLVMIsPackedStruct(LLVMTypeRef StructTy);
310 /* Operations on array, pointer, and vector types (sequence types) */
311 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
312 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
313 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
315 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
316 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
317 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
318 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
320 /* Operations on other types */
321 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C);
322 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C);
323 LLVMTypeRef LLVMOpaqueTypeInContext(LLVMContextRef C);
325 LLVMTypeRef LLVMVoidType(void);
326 LLVMTypeRef LLVMLabelType(void);
327 LLVMTypeRef LLVMOpaqueType(void);
329 /* Operations on type handles */
330 LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
331 void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
332 LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
333 void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
336 /*===-- Values ------------------------------------------------------------===*/
338 /* The bulk of LLVM's object model consists of values, which comprise a very
339 * rich type hierarchy.
342 #define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \
348 macro(ConstantAggregateZero) \
349 macro(ConstantArray) \
350 macro(ConstantExpr) \
353 macro(ConstantPointerNull) \
354 macro(ConstantStruct) \
355 macro(ConstantVector) \
359 macro(GlobalVariable) \
362 macro(BinaryOperator) \
364 macro(IntrinsicInst) \
365 macro(DbgInfoIntrinsic) \
366 macro(DbgDeclareInst) \
367 macro(DbgFuncStartInst) \
368 macro(DbgRegionEndInst) \
369 macro(DbgRegionStartInst) \
370 macro(DbgStopPointInst) \
371 macro(EHSelectorInst) \
372 macro(MemIntrinsic) \
379 macro(ExtractElementInst) \
380 macro(GetElementPtrInst) \
381 macro(InsertElementInst) \
382 macro(InsertValueInst) \
385 macro(ShuffleVectorInst) \
387 macro(TerminatorInst) \
392 macro(UnreachableInst) \
394 macro(UnaryInstruction) \
395 macro(AllocationInst) \
404 macro(IntToPtrInst) \
405 macro(PtrToIntInst) \
411 macro(ExtractValueInst) \
416 /* Operations on all values */
417 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
418 const char *LLVMGetValueName(LLVMValueRef Val);
419 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
420 void LLVMDumpValue(LLVMValueRef Val);
422 /* Conversion functions. Return the input value if it is an instance of the
423 specified class, otherwise NULL. See llvm::dyn_cast_or_null<>. */
424 #define LLVM_DECLARE_VALUE_CAST(name) \
425 LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
426 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST)
428 /* Operations on constants of any type */
429 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
430 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
431 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
432 int LLVMIsConstant(LLVMValueRef Val);
433 int LLVMIsNull(LLVMValueRef Val);
434 int LLVMIsUndef(LLVMValueRef Val);
435 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
437 /* Operations on scalar constants */
438 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
440 LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text,
442 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text,
443 unsigned SLen, uint8_t Radix);
444 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
445 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
446 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text,
450 /* Operations on composite constants */
451 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
452 unsigned Length, int DontNullTerminate);
453 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
454 LLVMValueRef *ConstantVals,
455 unsigned Count, int Packed);
457 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
458 int DontNullTerminate);
459 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
460 LLVMValueRef *ConstantVals, unsigned Length);
461 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
463 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
465 /* Constant expressions */
466 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty);
467 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
468 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
469 LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal);
470 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
471 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
472 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
473 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
474 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
475 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
476 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
477 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
478 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
479 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
480 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
481 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
482 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
483 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
484 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
485 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
486 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
487 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
488 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
489 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
490 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
491 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
492 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
493 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
494 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
495 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
496 LLVMValueRef *ConstantIndices, unsigned NumIndices);
497 LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
498 LLVMValueRef *ConstantIndices,
499 unsigned NumIndices);
500 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
501 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
502 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
503 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
504 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
505 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
506 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
507 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
508 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
509 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
510 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
511 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
512 LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,
514 LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,
516 LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,
518 LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal,
520 LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType,
522 LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
523 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
524 LLVMValueRef ConstantIfTrue,
525 LLVMValueRef ConstantIfFalse);
526 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
527 LLVMValueRef IndexConstant);
528 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
529 LLVMValueRef ElementValueConstant,
530 LLVMValueRef IndexConstant);
531 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
532 LLVMValueRef VectorBConstant,
533 LLVMValueRef MaskConstant);
534 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
536 LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
537 LLVMValueRef ElementValueConstant,
538 unsigned *IdxList, unsigned NumIdx);
539 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty,
540 const char *AsmString, const char *Constraints,
543 /* Operations on global variables, functions, and aliases (globals) */
544 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
545 int LLVMIsDeclaration(LLVMValueRef Global);
546 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
547 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
548 const char *LLVMGetSection(LLVMValueRef Global);
549 void LLVMSetSection(LLVMValueRef Global, const char *Section);
550 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
551 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
552 unsigned LLVMGetAlignment(LLVMValueRef Global);
553 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
555 /* Operations on global variables */
556 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
557 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
558 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
559 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
560 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
561 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
562 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
563 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
564 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
565 int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
566 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
567 int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
568 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
570 /* Operations on aliases */
571 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
574 /* Operations on functions */
575 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
576 LLVMTypeRef FunctionTy);
577 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
578 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
579 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
580 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
581 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
582 void LLVMDeleteFunction(LLVMValueRef Fn);
583 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
584 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
585 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
586 const char *LLVMGetGC(LLVMValueRef Fn);
587 void LLVMSetGC(LLVMValueRef Fn, const char *Name);
588 void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
589 void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
591 /* Operations on parameters */
592 unsigned LLVMCountParams(LLVMValueRef Fn);
593 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
594 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
595 LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
596 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
597 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
598 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
599 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
600 void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA);
601 void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA);
602 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align);
604 /* Operations on basic blocks */
605 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
606 int LLVMValueIsBasicBlock(LLVMValueRef Val);
607 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
608 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
609 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
610 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
611 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
612 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
613 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
614 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
615 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
617 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
620 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
621 LLVMBasicBlockRef BB,
624 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
625 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
627 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
629 /* Operations on instructions */
630 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
631 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
632 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
633 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
634 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
636 /* Operations on call sites */
637 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
638 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
639 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
640 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
642 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
645 /* Operations on call instructions (only) */
646 int LLVMIsTailCall(LLVMValueRef CallInst);
647 void LLVMSetTailCall(LLVMValueRef CallInst, int IsTailCall);
649 /* Operations on phi nodes */
650 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
651 LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
652 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
653 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
654 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
656 /*===-- Instruction builders ----------------------------------------------===*/
658 /* An instruction builder represents a point within a basic block, and is the
659 * exclusive means of building instructions using the C interface.
662 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
663 LLVMBuilderRef LLVMCreateBuilder(void);
664 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
666 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
667 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
668 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
669 void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
670 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
671 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
673 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
676 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
677 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
678 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
680 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
681 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
682 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
683 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
684 LLVMBasicBlockRef Else, unsigned NumCases);
685 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
686 LLVMValueRef *Args, unsigned NumArgs,
687 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
689 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
690 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
692 /* Add a case to the switch instruction */
693 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
694 LLVMBasicBlockRef Dest);
697 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
699 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
701 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
703 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
705 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
707 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
709 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
711 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
713 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
715 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
717 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
719 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
721 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
723 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
725 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
727 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
729 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
731 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
733 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
735 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
737 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
738 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
741 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
742 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
743 LLVMValueRef Val, const char *Name);
744 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
745 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
746 LLVMValueRef Val, const char *Name);
747 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
748 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
750 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
751 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
752 LLVMValueRef *Indices, unsigned NumIndices,
754 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
755 LLVMValueRef *Indices, unsigned NumIndices,
757 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
758 unsigned Idx, const char *Name);
759 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
761 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
765 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
766 LLVMTypeRef DestTy, const char *Name);
767 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
768 LLVMTypeRef DestTy, const char *Name);
769 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
770 LLVMTypeRef DestTy, const char *Name);
771 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
772 LLVMTypeRef DestTy, const char *Name);
773 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
774 LLVMTypeRef DestTy, const char *Name);
775 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
776 LLVMTypeRef DestTy, const char *Name);
777 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
778 LLVMTypeRef DestTy, const char *Name);
779 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
780 LLVMTypeRef DestTy, const char *Name);
781 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
782 LLVMTypeRef DestTy, const char *Name);
783 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
784 LLVMTypeRef DestTy, const char *Name);
785 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
786 LLVMTypeRef DestTy, const char *Name);
787 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
788 LLVMTypeRef DestTy, const char *Name);
789 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
790 LLVMTypeRef DestTy, const char *Name);
791 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
792 LLVMTypeRef DestTy, const char *Name);
793 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
794 LLVMTypeRef DestTy, const char *Name);
795 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
796 LLVMTypeRef DestTy, const char *Name);
797 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val,
798 LLVMTypeRef DestTy, const char *Name);
799 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
800 LLVMTypeRef DestTy, const char *Name);
803 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
804 LLVMValueRef LHS, LLVMValueRef RHS,
806 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
807 LLVMValueRef LHS, LLVMValueRef RHS,
810 /* Miscellaneous instructions */
811 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
812 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
813 LLVMValueRef *Args, unsigned NumArgs,
815 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
816 LLVMValueRef Then, LLVMValueRef Else,
818 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
820 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
821 LLVMValueRef Index, const char *Name);
822 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
823 LLVMValueRef EltVal, LLVMValueRef Index,
825 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
826 LLVMValueRef V2, LLVMValueRef Mask,
828 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
829 unsigned Index, const char *Name);
830 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
831 LLVMValueRef EltVal, unsigned Index,
834 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
836 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
838 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
839 LLVMValueRef RHS, const char *Name);
842 /*===-- Module providers --------------------------------------------------===*/
844 /* Encapsulates the module M in a module provider, taking ownership of the
846 * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
848 LLVMModuleProviderRef
849 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
851 /* Destroys the module provider MP as well as the contained module.
852 * See the destructor llvm::ModuleProvider::~ModuleProvider.
854 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP);
857 /*===-- Memory buffers ----------------------------------------------------===*/
859 int LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
860 LLVMMemoryBufferRef *OutMemBuf,
862 int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
864 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
867 /*===-- Pass Managers -----------------------------------------------------===*/
869 /** Constructs a new whole-module pass pipeline. This type of pipeline is
870 suitable for link-time optimization and whole-module transformations.
871 See llvm::PassManager::PassManager. */
872 LLVMPassManagerRef LLVMCreatePassManager(void);
874 /** Constructs a new function-by-function pass pipeline over the module
875 provider. It does not take ownership of the module provider. This type of
876 pipeline is suitable for code generation and JIT compilation tasks.
877 See llvm::FunctionPassManager::FunctionPassManager. */
878 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
880 /** Initializes, executes on the provided module, and finalizes all of the
881 passes scheduled in the pass manager. Returns 1 if any of the passes
882 modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */
883 int LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
885 /** Initializes all of the function passes scheduled in the function pass
886 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
887 See llvm::FunctionPassManager::doInitialization. */
888 int LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
890 /** Executes all of the function passes scheduled in the function pass manager
891 on the provided function. Returns 1 if any of the passes modified the
892 function, false otherwise.
893 See llvm::FunctionPassManager::run(Function&). */
894 int LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
896 /** Finalizes all of the function passes scheduled in in the function pass
897 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
898 See llvm::FunctionPassManager::doFinalization. */
899 int LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
901 /** Frees the memory of a pass pipeline. For function pipelines, does not free
903 See llvm::PassManagerBase::~PassManagerBase. */
904 void LLVMDisposePassManager(LLVMPassManagerRef PM);
911 class ModuleProvider;
913 class PassManagerBase;
915 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
916 inline ty *unwrap(ref P) { \
917 return reinterpret_cast<ty*>(P); \
920 inline ref wrap(const ty *P) { \
921 return reinterpret_cast<ref>(const_cast<ty*>(P)); \
924 #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref) \
925 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
927 template<typename T> \
928 inline T *unwrap(ref P) { \
929 return cast<T>(unwrap(P)); \
932 #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref) \
933 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
935 template<typename T> \
936 inline T *unwrap(ref P) { \
937 T *Q = dynamic_cast<T*>(unwrap(P)); \
938 assert(Q && "Invalid cast!"); \
942 DEFINE_ISA_CONVERSION_FUNCTIONS (Type, LLVMTypeRef )
943 DEFINE_ISA_CONVERSION_FUNCTIONS (Value, LLVMValueRef )
944 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef )
945 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef )
946 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef )
947 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder, LLVMTypeHandleRef )
948 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider, LLVMModuleProviderRef)
949 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef )
950 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext, LLVMContextRef )
951 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef )
953 #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS
954 #undef DEFINE_ISA_CONVERSION_FUNCTIONS
955 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
957 /* Specialized opaque context conversions.
959 inline LLVMContext **unwrap(LLVMContextRef* Tys) {
960 return reinterpret_cast<LLVMContext**>(Tys);
963 inline LLVMContextRef *wrap(const LLVMContext **Tys) {
964 return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys));
967 /* Specialized opaque type conversions.
969 inline Type **unwrap(LLVMTypeRef* Tys) {
970 return reinterpret_cast<Type**>(Tys);
973 inline LLVMTypeRef *wrap(const Type **Tys) {
974 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
977 /* Specialized opaque value conversions.
979 inline Value **unwrap(LLVMValueRef *Vals) {
980 return reinterpret_cast<Value**>(Vals);
984 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
986 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
989 return reinterpret_cast<T**>(Vals);
992 inline LLVMValueRef *wrap(const Value **Vals) {
993 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
997 #endif /* !defined(__cplusplus) */
999 #endif /* !defined(LLVM_C_CORE_H) */