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 * Used to iterate through the uses of a Value, allowing access to all Values
94 * that use this Value. See the llvm::Use and llvm::value_use_iterator classes.
96 typedef struct LLVMOpaqueUseIterator *LLVMUseIteratorRef;
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 LLVMNoCaptureAttribute = 1<<21,
116 LLVMNoRedZoneAttribute = 1<<22,
117 LLVMNoImplicitFloatAttribute = 1<<23,
118 LLVMNakedAttribute = 1<<24,
119 LLVMInlineHintAttribute = 1<<25
152 LLVMGetElementPtr = 30,
171 LLVMExtractElement = 51,
172 LLVMInsertElement = 52,
173 LLVMShuffleVector = 53,
174 LLVMExtractValue = 54,
179 LLVMVoidTypeKind, /**< type with no size */
180 LLVMFloatTypeKind, /**< 32 bit floating point type */
181 LLVMDoubleTypeKind, /**< 64 bit floating point type */
182 LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */
183 LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/
184 LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */
185 LLVMLabelTypeKind, /**< Labels */
186 LLVMIntegerTypeKind, /**< Arbitrary bit width integers */
187 LLVMFunctionTypeKind, /**< Functions */
188 LLVMStructTypeKind, /**< Structures */
189 LLVMArrayTypeKind, /**< Arrays */
190 LLVMPointerTypeKind, /**< Pointers */
191 LLVMOpaqueTypeKind, /**< Opaque: type with unknown structure */
192 LLVMVectorTypeKind, /**< SIMD 'packed' format, or other vector type */
193 LLVMMetadataTypeKind /**< Metadata */
197 LLVMExternalLinkage, /**< Externally visible function */
198 LLVMAvailableExternallyLinkage,
199 LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
200 LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
202 LLVMWeakAnyLinkage, /**< Keep one copy of function when linking (weak) */
203 LLVMWeakODRLinkage, /**< Same, but only replaced by something
205 LLVMAppendingLinkage, /**< Special purpose, only applies to global arrays */
206 LLVMInternalLinkage, /**< Rename collisions when linking (static
208 LLVMPrivateLinkage, /**< Like Internal, but omit from symbol table */
209 LLVMDLLImportLinkage, /**< Function to be imported from DLL */
210 LLVMDLLExportLinkage, /**< Function to be accessible from DLL */
211 LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
212 LLVMGhostLinkage, /**< Stand-in functions for streaming fns from
214 LLVMCommonLinkage, /**< Tentative definitions */
215 LLVMLinkerPrivateLinkage /**< Like Private, but linker removes. */
219 LLVMDefaultVisibility, /**< The GV is visible */
220 LLVMHiddenVisibility, /**< The GV is hidden */
221 LLVMProtectedVisibility /**< The GV is protected */
226 LLVMFastCallConv = 8,
227 LLVMColdCallConv = 9,
228 LLVMX86StdcallCallConv = 64,
229 LLVMX86FastcallCallConv = 65
233 LLVMIntEQ = 32, /**< equal */
234 LLVMIntNE, /**< not equal */
235 LLVMIntUGT, /**< unsigned greater than */
236 LLVMIntUGE, /**< unsigned greater or equal */
237 LLVMIntULT, /**< unsigned less than */
238 LLVMIntULE, /**< unsigned less or equal */
239 LLVMIntSGT, /**< signed greater than */
240 LLVMIntSGE, /**< signed greater or equal */
241 LLVMIntSLT, /**< signed less than */
242 LLVMIntSLE /**< signed less or equal */
246 LLVMRealPredicateFalse, /**< Always false (always folded) */
247 LLVMRealOEQ, /**< True if ordered and equal */
248 LLVMRealOGT, /**< True if ordered and greater than */
249 LLVMRealOGE, /**< True if ordered and greater than or equal */
250 LLVMRealOLT, /**< True if ordered and less than */
251 LLVMRealOLE, /**< True if ordered and less than or equal */
252 LLVMRealONE, /**< True if ordered and operands are unequal */
253 LLVMRealORD, /**< True if ordered (no nans) */
254 LLVMRealUNO, /**< True if unordered: isnan(X) | isnan(Y) */
255 LLVMRealUEQ, /**< True if unordered or equal */
256 LLVMRealUGT, /**< True if unordered or greater than */
257 LLVMRealUGE, /**< True if unordered, greater than, or equal */
258 LLVMRealULT, /**< True if unordered or less than */
259 LLVMRealULE, /**< True if unordered, less than, or equal */
260 LLVMRealUNE, /**< True if unordered or not equal */
261 LLVMRealPredicateTrue /**< Always true (always folded) */
265 /*===-- Error handling ----------------------------------------------------===*/
267 void LLVMDisposeMessage(char *Message);
270 /*===-- Modules -----------------------------------------------------------===*/
272 /* Create and destroy contexts. */
273 LLVMContextRef LLVMContextCreate(void);
274 LLVMContextRef LLVMGetGlobalContext(void);
275 void LLVMContextDispose(LLVMContextRef C);
277 /* Create and destroy modules. */
278 /** See llvm::Module::Module. */
279 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
280 LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
283 /** See llvm::Module::~Module. */
284 void LLVMDisposeModule(LLVMModuleRef M);
286 /** Data layout. See Module::getDataLayout. */
287 const char *LLVMGetDataLayout(LLVMModuleRef M);
288 void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple);
290 /** Target triple. See Module::getTargetTriple. */
291 const char *LLVMGetTarget(LLVMModuleRef M);
292 void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
294 /** See Module::addTypeName. */
295 int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
296 void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
297 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name);
299 /** See Module::dump. */
300 void LLVMDumpModule(LLVMModuleRef M);
303 /*===-- Types -------------------------------------------------------------===*/
305 /* LLVM types conform to the following hierarchy:
320 /** See llvm::LLVMTypeKind::getTypeID. */
321 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
323 /** See llvm::LLVMType::getContext. */
324 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty);
326 /* Operations on integer types */
327 LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C);
328 LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C);
329 LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C);
330 LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C);
331 LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C);
332 LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits);
334 LLVMTypeRef LLVMInt1Type(void);
335 LLVMTypeRef LLVMInt8Type(void);
336 LLVMTypeRef LLVMInt16Type(void);
337 LLVMTypeRef LLVMInt32Type(void);
338 LLVMTypeRef LLVMInt64Type(void);
339 LLVMTypeRef LLVMIntType(unsigned NumBits);
340 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
342 /* Operations on real types */
343 LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C);
344 LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C);
345 LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C);
346 LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C);
347 LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C);
349 LLVMTypeRef LLVMFloatType(void);
350 LLVMTypeRef LLVMDoubleType(void);
351 LLVMTypeRef LLVMX86FP80Type(void);
352 LLVMTypeRef LLVMFP128Type(void);
353 LLVMTypeRef LLVMPPCFP128Type(void);
355 /* Operations on function types */
356 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
357 LLVMTypeRef *ParamTypes, unsigned ParamCount,
359 int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
360 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
361 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
362 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
364 /* Operations on struct types */
365 LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
366 unsigned ElementCount, int Packed);
367 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
369 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
370 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
371 int LLVMIsPackedStruct(LLVMTypeRef StructTy);
373 /* Operations on array, pointer, and vector types (sequence types) */
374 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
375 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
376 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
378 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
379 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
380 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
381 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
383 /* Operations on other types */
384 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C);
385 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C);
386 LLVMTypeRef LLVMOpaqueTypeInContext(LLVMContextRef C);
388 LLVMTypeRef LLVMVoidType(void);
389 LLVMTypeRef LLVMLabelType(void);
390 LLVMTypeRef LLVMOpaqueType(void);
392 /* Operations on type handles */
393 LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
394 void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
395 LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
396 void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
399 /*===-- Values ------------------------------------------------------------===*/
401 /* The bulk of LLVM's object model consists of values, which comprise a very
402 * rich type hierarchy.
405 #define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \
411 macro(ConstantAggregateZero) \
412 macro(ConstantArray) \
413 macro(ConstantExpr) \
416 macro(ConstantPointerNull) \
417 macro(ConstantStruct) \
418 macro(ConstantVector) \
422 macro(GlobalVariable) \
425 macro(BinaryOperator) \
427 macro(IntrinsicInst) \
428 macro(DbgInfoIntrinsic) \
429 macro(DbgDeclareInst) \
430 macro(DbgFuncStartInst) \
431 macro(DbgRegionEndInst) \
432 macro(DbgRegionStartInst) \
433 macro(DbgStopPointInst) \
434 macro(EHSelectorInst) \
435 macro(MemIntrinsic) \
442 macro(ExtractElementInst) \
443 macro(GetElementPtrInst) \
444 macro(InsertElementInst) \
445 macro(InsertValueInst) \
448 macro(ShuffleVectorInst) \
450 macro(TerminatorInst) \
455 macro(UnreachableInst) \
457 macro(UnaryInstruction) \
458 macro(AllocationInst) \
467 macro(IntToPtrInst) \
468 macro(PtrToIntInst) \
474 macro(ExtractValueInst) \
479 /* Operations on all values */
480 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
481 const char *LLVMGetValueName(LLVMValueRef Val);
482 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
483 void LLVMDumpValue(LLVMValueRef Val);
484 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
486 /* Conversion functions. Return the input value if it is an instance of the
487 specified class, otherwise NULL. See llvm::dyn_cast_or_null<>. */
488 #define LLVM_DECLARE_VALUE_CAST(name) \
489 LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
490 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST)
492 /* Operations on Uses */
493 LLVMUseIteratorRef LLVMGetFirstUse(LLVMValueRef Val);
494 LLVMUseIteratorRef LLVMGetNextUse(LLVMUseIteratorRef U);
495 LLVMValueRef LLVMGetUser(LLVMUseIteratorRef U);
496 LLVMValueRef LLVMGetUsedValue(LLVMUseIteratorRef U);
498 /* Operations on Users */
499 LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index);
501 /* Operations on constants of any type */
502 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
503 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
504 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
505 int LLVMIsConstant(LLVMValueRef Val);
506 int LLVMIsNull(LLVMValueRef Val);
507 int LLVMIsUndef(LLVMValueRef Val);
508 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
510 /* Operations on scalar constants */
511 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
513 LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text,
515 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text,
516 unsigned SLen, uint8_t Radix);
517 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
518 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
519 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text,
521 unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal);
522 long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal);
525 /* Operations on composite constants */
526 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
527 unsigned Length, int DontNullTerminate);
528 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
529 LLVMValueRef *ConstantVals,
530 unsigned Count, int Packed);
532 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
533 int DontNullTerminate);
534 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
535 LLVMValueRef *ConstantVals, unsigned Length);
536 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
538 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
540 /* Constant expressions */
541 LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal);
542 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty);
543 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
544 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
545 LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal);
546 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
547 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
548 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
549 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
550 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
551 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
552 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
553 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
554 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
555 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
556 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
557 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
558 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
559 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
560 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
561 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
562 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
563 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
564 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
565 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
566 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
567 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
568 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
569 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
570 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
571 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
572 LLVMValueRef *ConstantIndices, unsigned NumIndices);
573 LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
574 LLVMValueRef *ConstantIndices,
575 unsigned NumIndices);
576 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
577 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
578 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
579 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
580 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
581 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
582 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
583 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
584 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
585 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
586 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
587 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
588 LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,
590 LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,
592 LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,
594 LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal,
596 LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType,
598 LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
599 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
600 LLVMValueRef ConstantIfTrue,
601 LLVMValueRef ConstantIfFalse);
602 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
603 LLVMValueRef IndexConstant);
604 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
605 LLVMValueRef ElementValueConstant,
606 LLVMValueRef IndexConstant);
607 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
608 LLVMValueRef VectorBConstant,
609 LLVMValueRef MaskConstant);
610 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
612 LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
613 LLVMValueRef ElementValueConstant,
614 unsigned *IdxList, unsigned NumIdx);
615 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty,
616 const char *AsmString, const char *Constraints,
619 /* Operations on global variables, functions, and aliases (globals) */
620 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
621 int LLVMIsDeclaration(LLVMValueRef Global);
622 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
623 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
624 const char *LLVMGetSection(LLVMValueRef Global);
625 void LLVMSetSection(LLVMValueRef Global, const char *Section);
626 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
627 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
628 unsigned LLVMGetAlignment(LLVMValueRef Global);
629 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
631 /* Operations on global variables */
632 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
633 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
634 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
635 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
636 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
637 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
638 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
639 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
640 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
641 int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
642 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
643 int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
644 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
646 /* Operations on aliases */
647 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
650 /* Operations on functions */
651 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
652 LLVMTypeRef FunctionTy);
653 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
654 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
655 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
656 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
657 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
658 void LLVMDeleteFunction(LLVMValueRef Fn);
659 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
660 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
661 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
662 const char *LLVMGetGC(LLVMValueRef Fn);
663 void LLVMSetGC(LLVMValueRef Fn, const char *Name);
664 void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
665 LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn);
666 void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
668 /* Operations on parameters */
669 unsigned LLVMCountParams(LLVMValueRef Fn);
670 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
671 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
672 LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
673 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
674 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
675 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
676 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
677 void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA);
678 void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA);
679 LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg);
680 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align);
682 /* Operations on basic blocks */
683 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
684 int LLVMValueIsBasicBlock(LLVMValueRef Val);
685 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
686 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
687 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
688 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
689 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
690 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
691 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
692 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
693 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
695 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
698 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
699 LLVMBasicBlockRef BB,
702 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
703 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
705 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
707 /* Operations on instructions */
708 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
709 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
710 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
711 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
712 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
714 /* Operations on call sites */
715 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
716 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
717 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
718 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
720 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
723 /* Operations on call instructions (only) */
724 int LLVMIsTailCall(LLVMValueRef CallInst);
725 void LLVMSetTailCall(LLVMValueRef CallInst, int IsTailCall);
727 /* Operations on phi nodes */
728 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
729 LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
730 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
731 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
732 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
734 /*===-- Instruction builders ----------------------------------------------===*/
736 /* An instruction builder represents a point within a basic block, and is the
737 * exclusive means of building instructions using the C interface.
740 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
741 LLVMBuilderRef LLVMCreateBuilder(void);
742 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
744 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
745 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
746 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
747 void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
748 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
749 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
751 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
754 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
755 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
756 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
758 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
759 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
760 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
761 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
762 LLVMBasicBlockRef Else, unsigned NumCases);
763 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
764 LLVMValueRef *Args, unsigned NumArgs,
765 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
767 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
768 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
770 /* Add a case to the switch instruction */
771 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
772 LLVMBasicBlockRef Dest);
775 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
777 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
779 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
781 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
783 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
785 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
787 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
789 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
791 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
793 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
795 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
797 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
799 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
801 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
803 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
805 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
807 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
809 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
811 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
813 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
815 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
816 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
817 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
820 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
821 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
822 LLVMValueRef Val, const char *Name);
823 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
824 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
825 LLVMValueRef Val, const char *Name);
826 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
827 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
829 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
830 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
831 LLVMValueRef *Indices, unsigned NumIndices,
833 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
834 LLVMValueRef *Indices, unsigned NumIndices,
836 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
837 unsigned Idx, const char *Name);
838 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
840 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
844 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
845 LLVMTypeRef DestTy, const char *Name);
846 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
847 LLVMTypeRef DestTy, const char *Name);
848 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
849 LLVMTypeRef DestTy, const char *Name);
850 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
851 LLVMTypeRef DestTy, const char *Name);
852 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
853 LLVMTypeRef DestTy, const char *Name);
854 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
855 LLVMTypeRef DestTy, const char *Name);
856 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
857 LLVMTypeRef DestTy, const char *Name);
858 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
859 LLVMTypeRef DestTy, const char *Name);
860 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
861 LLVMTypeRef DestTy, const char *Name);
862 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
863 LLVMTypeRef DestTy, const char *Name);
864 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
865 LLVMTypeRef DestTy, const char *Name);
866 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
867 LLVMTypeRef DestTy, const char *Name);
868 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
869 LLVMTypeRef DestTy, const char *Name);
870 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
871 LLVMTypeRef DestTy, const char *Name);
872 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
873 LLVMTypeRef DestTy, const char *Name);
874 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
875 LLVMTypeRef DestTy, const char *Name);
876 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val,
877 LLVMTypeRef DestTy, const char *Name);
878 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
879 LLVMTypeRef DestTy, const char *Name);
882 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
883 LLVMValueRef LHS, LLVMValueRef RHS,
885 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
886 LLVMValueRef LHS, LLVMValueRef RHS,
889 /* Miscellaneous instructions */
890 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
891 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
892 LLVMValueRef *Args, unsigned NumArgs,
894 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
895 LLVMValueRef Then, LLVMValueRef Else,
897 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
899 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
900 LLVMValueRef Index, const char *Name);
901 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
902 LLVMValueRef EltVal, LLVMValueRef Index,
904 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
905 LLVMValueRef V2, LLVMValueRef Mask,
907 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
908 unsigned Index, const char *Name);
909 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
910 LLVMValueRef EltVal, unsigned Index,
913 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
915 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
917 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
918 LLVMValueRef RHS, const char *Name);
921 /*===-- Module providers --------------------------------------------------===*/
923 /* Encapsulates the module M in a module provider, taking ownership of the
925 * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
927 LLVMModuleProviderRef
928 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
930 /* Destroys the module provider MP as well as the contained module.
931 * See the destructor llvm::ModuleProvider::~ModuleProvider.
933 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP);
936 /*===-- Memory buffers ----------------------------------------------------===*/
938 int LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
939 LLVMMemoryBufferRef *OutMemBuf,
941 int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
943 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
946 /*===-- Pass Managers -----------------------------------------------------===*/
948 /** Constructs a new whole-module pass pipeline. This type of pipeline is
949 suitable for link-time optimization and whole-module transformations.
950 See llvm::PassManager::PassManager. */
951 LLVMPassManagerRef LLVMCreatePassManager(void);
953 /** Constructs a new function-by-function pass pipeline over the module
954 provider. It does not take ownership of the module provider. This type of
955 pipeline is suitable for code generation and JIT compilation tasks.
956 See llvm::FunctionPassManager::FunctionPassManager. */
957 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
959 /** Initializes, executes on the provided module, and finalizes all of the
960 passes scheduled in the pass manager. Returns 1 if any of the passes
961 modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */
962 int LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
964 /** Initializes all of the function passes scheduled in the function pass
965 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
966 See llvm::FunctionPassManager::doInitialization. */
967 int LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
969 /** Executes all of the function passes scheduled in the function pass manager
970 on the provided function. Returns 1 if any of the passes modified the
971 function, false otherwise.
972 See llvm::FunctionPassManager::run(Function&). */
973 int LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
975 /** Finalizes all of the function passes scheduled in in the function pass
976 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
977 See llvm::FunctionPassManager::doFinalization. */
978 int LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
980 /** Frees the memory of a pass pipeline. For function pipelines, does not free
982 See llvm::PassManagerBase::~PassManagerBase. */
983 void LLVMDisposePassManager(LLVMPassManagerRef PM);
990 class ModuleProvider;
992 class PassManagerBase;
994 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
995 inline ty *unwrap(ref P) { \
996 return reinterpret_cast<ty*>(P); \
999 inline ref wrap(const ty *P) { \
1000 return reinterpret_cast<ref>(const_cast<ty*>(P)); \
1003 #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref) \
1004 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
1006 template<typename T> \
1007 inline T *unwrap(ref P) { \
1008 return cast<T>(unwrap(P)); \
1011 #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref) \
1012 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
1014 template<typename T> \
1015 inline T *unwrap(ref P) { \
1016 T *Q = dynamic_cast<T*>(unwrap(P)); \
1017 assert(Q && "Invalid cast!"); \
1021 DEFINE_ISA_CONVERSION_FUNCTIONS (Type, LLVMTypeRef )
1022 DEFINE_ISA_CONVERSION_FUNCTIONS (Value, LLVMValueRef )
1023 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef )
1024 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef )
1025 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef )
1026 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder, LLVMTypeHandleRef )
1027 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider, LLVMModuleProviderRef)
1028 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef )
1029 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext, LLVMContextRef )
1030 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Use, LLVMUseIteratorRef )
1031 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef )
1033 #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS
1034 #undef DEFINE_ISA_CONVERSION_FUNCTIONS
1035 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
1037 /* Specialized opaque context conversions.
1039 inline LLVMContext **unwrap(LLVMContextRef* Tys) {
1040 return reinterpret_cast<LLVMContext**>(Tys);
1043 inline LLVMContextRef *wrap(const LLVMContext **Tys) {
1044 return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys));
1047 /* Specialized opaque type conversions.
1049 inline Type **unwrap(LLVMTypeRef* Tys) {
1050 return reinterpret_cast<Type**>(Tys);
1053 inline LLVMTypeRef *wrap(const Type **Tys) {
1054 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
1057 /* Specialized opaque value conversions.
1059 inline Value **unwrap(LLVMValueRef *Vals) {
1060 return reinterpret_cast<Value**>(Vals);
1063 template<typename T>
1064 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
1066 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
1069 return reinterpret_cast<T**>(Vals);
1072 inline LLVMValueRef *wrap(const Value **Vals) {
1073 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
1077 #endif /* !defined(__cplusplus) */
1079 #endif /* !defined(LLVM_C_CORE_H) */