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/System/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"
54 * The top-level container for all LLVM global data. See the LLVMContext class.
56 typedef struct LLVMOpaqueContext *LLVMContextRef;
59 * The top-level container for all other LLVM Intermediate Representation (IR)
60 * objects. See the llvm::Module class.
62 typedef struct LLVMOpaqueModule *LLVMModuleRef;
65 * Each value in the LLVM IR has a type, an LLVMTypeRef. See the llvm::Type
68 typedef struct LLVMOpaqueType *LLVMTypeRef;
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.
75 typedef struct LLVMOpaqueTypeHandle *LLVMTypeHandleRef;
77 typedef struct LLVMOpaqueValue *LLVMValueRef;
78 typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
79 typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
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.
85 typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
87 /* Used to provide a module to JIT or interpreter.
88 * See the llvm::MemoryBuffer class.
90 typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef;
92 /** See the llvm::PassManagerBase class. */
93 typedef struct LLVMOpaquePassManager *LLVMPassManagerRef;
96 * Used to iterate through the uses of a Value, allowing access to all Values
97 * that use this Value. See the llvm::Use and llvm::value_use_iterator classes.
99 typedef struct LLVMOpaqueUseIterator *LLVMUseIteratorRef;
102 LLVMZExtAttribute = 1<<0,
103 LLVMSExtAttribute = 1<<1,
104 LLVMNoReturnAttribute = 1<<2,
105 LLVMInRegAttribute = 1<<3,
106 LLVMStructRetAttribute = 1<<4,
107 LLVMNoUnwindAttribute = 1<<5,
108 LLVMNoAliasAttribute = 1<<6,
109 LLVMByValAttribute = 1<<7,
110 LLVMNestAttribute = 1<<8,
111 LLVMReadNoneAttribute = 1<<9,
112 LLVMReadOnlyAttribute = 1<<10,
113 LLVMNoInlineAttribute = 1<<11,
114 LLVMAlwaysInlineAttribute = 1<<12,
115 LLVMOptimizeForSizeAttribute = 1<<13,
116 LLVMStackProtectAttribute = 1<<14,
117 LLVMStackProtectReqAttribute = 1<<15,
118 LLVMNoCaptureAttribute = 1<<21,
119 LLVMNoRedZoneAttribute = 1<<22,
120 LLVMNoImplicitFloatAttribute = 1<<23,
121 LLVMNakedAttribute = 1<<24,
122 LLVMInlineHintAttribute = 1<<25
126 /* Terminator Instructions */
135 /* Standard Binary Operators */
149 /* Logical Operators */
157 /* Memory Operators */
161 LLVMGetElementPtr = 29,
177 /* Other Operators */
186 LLVMExtractElement = 50,
187 LLVMInsertElement = 51,
188 LLVMShuffleVector = 52,
189 LLVMExtractValue = 53,
194 LLVMVoidTypeKind, /**< type with no size */
195 LLVMFloatTypeKind, /**< 32 bit floating point type */
196 LLVMDoubleTypeKind, /**< 64 bit floating point type */
197 LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */
198 LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/
199 LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */
200 LLVMLabelTypeKind, /**< Labels */
201 LLVMIntegerTypeKind, /**< Arbitrary bit width integers */
202 LLVMFunctionTypeKind, /**< Functions */
203 LLVMStructTypeKind, /**< Structures */
204 LLVMArrayTypeKind, /**< Arrays */
205 LLVMPointerTypeKind, /**< Pointers */
206 LLVMOpaqueTypeKind, /**< Opaque: type with unknown structure */
207 LLVMVectorTypeKind, /**< SIMD 'packed' format, or other vector type */
208 LLVMMetadataTypeKind, /**< Metadata */
209 LLVMUnionTypeKind /**< Unions */
213 LLVMExternalLinkage, /**< Externally visible function */
214 LLVMAvailableExternallyLinkage,
215 LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
216 LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
218 LLVMWeakAnyLinkage, /**< Keep one copy of function when linking (weak) */
219 LLVMWeakODRLinkage, /**< Same, but only replaced by something
221 LLVMAppendingLinkage, /**< Special purpose, only applies to global arrays */
222 LLVMInternalLinkage, /**< Rename collisions when linking (static
224 LLVMPrivateLinkage, /**< Like Internal, but omit from symbol table */
225 LLVMDLLImportLinkage, /**< Function to be imported from DLL */
226 LLVMDLLExportLinkage, /**< Function to be accessible from DLL */
227 LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
228 LLVMGhostLinkage, /**< Obsolete */
229 LLVMCommonLinkage, /**< Tentative definitions */
230 LLVMLinkerPrivateLinkage /**< Like Private, but linker removes. */
234 LLVMDefaultVisibility, /**< The GV is visible */
235 LLVMHiddenVisibility, /**< The GV is hidden */
236 LLVMProtectedVisibility /**< The GV is protected */
241 LLVMFastCallConv = 8,
242 LLVMColdCallConv = 9,
243 LLVMX86StdcallCallConv = 64,
244 LLVMX86FastcallCallConv = 65
248 LLVMIntEQ = 32, /**< equal */
249 LLVMIntNE, /**< not equal */
250 LLVMIntUGT, /**< unsigned greater than */
251 LLVMIntUGE, /**< unsigned greater or equal */
252 LLVMIntULT, /**< unsigned less than */
253 LLVMIntULE, /**< unsigned less or equal */
254 LLVMIntSGT, /**< signed greater than */
255 LLVMIntSGE, /**< signed greater or equal */
256 LLVMIntSLT, /**< signed less than */
257 LLVMIntSLE /**< signed less or equal */
261 LLVMRealPredicateFalse, /**< Always false (always folded) */
262 LLVMRealOEQ, /**< True if ordered and equal */
263 LLVMRealOGT, /**< True if ordered and greater than */
264 LLVMRealOGE, /**< True if ordered and greater than or equal */
265 LLVMRealOLT, /**< True if ordered and less than */
266 LLVMRealOLE, /**< True if ordered and less than or equal */
267 LLVMRealONE, /**< True if ordered and operands are unequal */
268 LLVMRealORD, /**< True if ordered (no nans) */
269 LLVMRealUNO, /**< True if unordered: isnan(X) | isnan(Y) */
270 LLVMRealUEQ, /**< True if unordered or equal */
271 LLVMRealUGT, /**< True if unordered or greater than */
272 LLVMRealUGE, /**< True if unordered, greater than, or equal */
273 LLVMRealULT, /**< True if unordered or less than */
274 LLVMRealULE, /**< True if unordered, less than, or equal */
275 LLVMRealUNE, /**< True if unordered or not equal */
276 LLVMRealPredicateTrue /**< Always true (always folded) */
280 /*===-- Error handling ----------------------------------------------------===*/
282 void LLVMDisposeMessage(char *Message);
285 /*===-- Modules -----------------------------------------------------------===*/
287 /* Create and destroy contexts. */
288 LLVMContextRef LLVMContextCreate(void);
289 LLVMContextRef LLVMGetGlobalContext(void);
290 void LLVMContextDispose(LLVMContextRef C);
292 /* Create and destroy modules. */
293 /** See llvm::Module::Module. */
294 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
295 LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
298 /** See llvm::Module::~Module. */
299 void LLVMDisposeModule(LLVMModuleRef M);
301 /** Data layout. See Module::getDataLayout. */
302 const char *LLVMGetDataLayout(LLVMModuleRef M);
303 void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple);
305 /** Target triple. See Module::getTargetTriple. */
306 const char *LLVMGetTarget(LLVMModuleRef M);
307 void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
309 /** See Module::addTypeName. */
310 LLVMBool LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
311 void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
312 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name);
314 /** See Module::dump. */
315 void LLVMDumpModule(LLVMModuleRef M);
318 /*===-- Types -------------------------------------------------------------===*/
320 /* LLVM types conform to the following hierarchy:
335 /** See llvm::LLVMTypeKind::getTypeID. */
336 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
338 /** See llvm::LLVMType::getContext. */
339 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty);
341 /* Operations on integer types */
342 LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C);
343 LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C);
344 LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C);
345 LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C);
346 LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C);
347 LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits);
349 LLVMTypeRef LLVMInt1Type(void);
350 LLVMTypeRef LLVMInt8Type(void);
351 LLVMTypeRef LLVMInt16Type(void);
352 LLVMTypeRef LLVMInt32Type(void);
353 LLVMTypeRef LLVMInt64Type(void);
354 LLVMTypeRef LLVMIntType(unsigned NumBits);
355 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
357 /* Operations on real types */
358 LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C);
359 LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C);
360 LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C);
361 LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C);
362 LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C);
364 LLVMTypeRef LLVMFloatType(void);
365 LLVMTypeRef LLVMDoubleType(void);
366 LLVMTypeRef LLVMX86FP80Type(void);
367 LLVMTypeRef LLVMFP128Type(void);
368 LLVMTypeRef LLVMPPCFP128Type(void);
370 /* Operations on function types */
371 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
372 LLVMTypeRef *ParamTypes, unsigned ParamCount,
374 LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
375 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
376 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
377 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
379 /* Operations on struct types */
380 LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
381 unsigned ElementCount, LLVMBool Packed);
382 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
384 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
385 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
386 LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy);
388 /* Operations on union types */
389 LLVMTypeRef LLVMUnionTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
390 unsigned ElementCount);
391 LLVMTypeRef LLVMUnionType(LLVMTypeRef *ElementTypes, unsigned ElementCount);
392 unsigned LLVMCountUnionElementTypes(LLVMTypeRef UnionTy);
393 void LLVMGetUnionElementTypes(LLVMTypeRef UnionTy, LLVMTypeRef *Dest);
395 /* Operations on array, pointer, and vector types (sequence types) */
396 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
397 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
398 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
400 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
401 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
402 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
403 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
405 /* Operations on other types */
406 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C);
407 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C);
408 LLVMTypeRef LLVMOpaqueTypeInContext(LLVMContextRef C);
410 LLVMTypeRef LLVMVoidType(void);
411 LLVMTypeRef LLVMLabelType(void);
412 LLVMTypeRef LLVMOpaqueType(void);
414 /* Operations on type handles */
415 LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
416 void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
417 LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
418 void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
421 /*===-- Values ------------------------------------------------------------===*/
423 /* The bulk of LLVM's object model consists of values, which comprise a very
424 * rich type hierarchy.
427 #define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \
433 macro(ConstantAggregateZero) \
434 macro(ConstantArray) \
435 macro(ConstantExpr) \
438 macro(ConstantPointerNull) \
439 macro(ConstantStruct) \
440 macro(ConstantVector) \
444 macro(GlobalVariable) \
447 macro(BinaryOperator) \
449 macro(IntrinsicInst) \
450 macro(DbgInfoIntrinsic) \
451 macro(DbgDeclareInst) \
452 macro(EHSelectorInst) \
453 macro(MemIntrinsic) \
460 macro(ExtractElementInst) \
461 macro(GetElementPtrInst) \
462 macro(InsertElementInst) \
463 macro(InsertValueInst) \
466 macro(ShuffleVectorInst) \
468 macro(TerminatorInst) \
473 macro(UnreachableInst) \
475 macro(UnaryInstruction) \
483 macro(IntToPtrInst) \
484 macro(PtrToIntInst) \
490 macro(ExtractValueInst) \
494 /* Operations on all values */
495 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
496 const char *LLVMGetValueName(LLVMValueRef Val);
497 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
498 void LLVMDumpValue(LLVMValueRef Val);
499 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
501 /* Conversion functions. Return the input value if it is an instance of the
502 specified class, otherwise NULL. See llvm::dyn_cast_or_null<>. */
503 #define LLVM_DECLARE_VALUE_CAST(name) \
504 LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
505 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST)
507 /* Operations on Uses */
508 LLVMUseIteratorRef LLVMGetFirstUse(LLVMValueRef Val);
509 LLVMUseIteratorRef LLVMGetNextUse(LLVMUseIteratorRef U);
510 LLVMValueRef LLVMGetUser(LLVMUseIteratorRef U);
511 LLVMValueRef LLVMGetUsedValue(LLVMUseIteratorRef U);
513 /* Operations on Users */
514 LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index);
516 /* Operations on constants of any type */
517 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
518 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
519 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
520 LLVMBool LLVMIsConstant(LLVMValueRef Val);
521 LLVMBool LLVMIsNull(LLVMValueRef Val);
522 LLVMBool LLVMIsUndef(LLVMValueRef Val);
523 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
525 /* Operations on scalar constants */
526 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
527 LLVMBool SignExtend);
528 LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text,
530 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text,
531 unsigned SLen, uint8_t Radix);
532 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
533 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
534 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text,
536 unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal);
537 long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal);
540 /* Operations on composite constants */
541 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
542 unsigned Length, LLVMBool DontNullTerminate);
543 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
544 LLVMValueRef *ConstantVals,
545 unsigned Count, LLVMBool Packed);
547 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
548 LLVMBool DontNullTerminate);
549 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
550 LLVMValueRef *ConstantVals, unsigned Length);
551 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
553 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
554 LLVMValueRef LLVMConstUnion(LLVMTypeRef Ty, LLVMValueRef Val);
556 /* Constant expressions */
557 LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal);
558 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty);
559 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
560 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
561 LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal);
562 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
563 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
564 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
565 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
566 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
567 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
568 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
569 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
570 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
571 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
572 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
573 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
574 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
575 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
576 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
577 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
578 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
579 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
580 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
581 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
582 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
583 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
584 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
585 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
586 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
587 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
588 LLVMValueRef *ConstantIndices, unsigned NumIndices);
589 LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
590 LLVMValueRef *ConstantIndices,
591 unsigned NumIndices);
592 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
593 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
594 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
595 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
596 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
597 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
598 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
599 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
600 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
601 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
602 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
603 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
604 LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,
606 LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,
608 LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,
610 LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal,
612 LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType,
614 LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
615 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
616 LLVMValueRef ConstantIfTrue,
617 LLVMValueRef ConstantIfFalse);
618 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
619 LLVMValueRef IndexConstant);
620 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
621 LLVMValueRef ElementValueConstant,
622 LLVMValueRef IndexConstant);
623 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
624 LLVMValueRef VectorBConstant,
625 LLVMValueRef MaskConstant);
626 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
628 LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
629 LLVMValueRef ElementValueConstant,
630 unsigned *IdxList, unsigned NumIdx);
631 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty,
632 const char *AsmString, const char *Constraints,
633 LLVMBool HasSideEffects, LLVMBool IsAlignStack);
635 /* Operations on global variables, functions, and aliases (globals) */
636 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
637 LLVMBool LLVMIsDeclaration(LLVMValueRef Global);
638 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
639 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
640 const char *LLVMGetSection(LLVMValueRef Global);
641 void LLVMSetSection(LLVMValueRef Global, const char *Section);
642 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
643 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
644 unsigned LLVMGetAlignment(LLVMValueRef Global);
645 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
647 /* Operations on global variables */
648 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
649 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
650 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
651 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
652 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
653 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
654 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
655 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
656 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
657 LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar);
658 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal);
659 LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
660 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant);
662 /* Operations on aliases */
663 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
666 /* Operations on functions */
667 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
668 LLVMTypeRef FunctionTy);
669 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
670 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
671 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
672 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
673 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
674 void LLVMDeleteFunction(LLVMValueRef Fn);
675 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
676 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
677 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
678 const char *LLVMGetGC(LLVMValueRef Fn);
679 void LLVMSetGC(LLVMValueRef Fn, const char *Name);
680 void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
681 LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn);
682 void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
684 /* Operations on parameters */
685 unsigned LLVMCountParams(LLVMValueRef Fn);
686 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
687 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
688 LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
689 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
690 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
691 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
692 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
693 void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA);
694 void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA);
695 LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg);
696 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align);
698 /* Operations on basic blocks */
699 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
700 LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val);
701 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
702 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
703 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
704 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
705 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
706 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
707 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
708 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
709 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
711 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
714 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
715 LLVMBasicBlockRef BB,
718 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
719 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
721 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
723 /* Operations on instructions */
724 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
725 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
726 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
727 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
728 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
730 /* Operations on call sites */
731 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
732 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
733 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
734 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
736 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
739 /* Operations on call instructions (only) */
740 LLVMBool LLVMIsTailCall(LLVMValueRef CallInst);
741 void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall);
743 /* Operations on phi nodes */
744 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
745 LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
746 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
747 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
748 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
750 /*===-- Instruction builders ----------------------------------------------===*/
752 /* An instruction builder represents a point within a basic block, and is the
753 * exclusive means of building instructions using the C interface.
756 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
757 LLVMBuilderRef LLVMCreateBuilder(void);
758 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
760 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
761 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
762 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
763 void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
764 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
765 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
767 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
770 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
771 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
772 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
774 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
775 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
776 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
777 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
778 LLVMBasicBlockRef Else, unsigned NumCases);
779 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
780 LLVMValueRef *Args, unsigned NumArgs,
781 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
783 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
784 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
786 /* Add a case to the switch instruction */
787 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
788 LLVMBasicBlockRef Dest);
791 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
793 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
795 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
797 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
799 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
801 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
803 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
805 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
807 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
809 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
811 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
813 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
815 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
817 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
819 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
821 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
823 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
825 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
827 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
829 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
831 LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
832 LLVMValueRef LHS, LLVMValueRef RHS,
834 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
835 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
836 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
839 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
840 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
841 LLVMValueRef Val, const char *Name);
842 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
843 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
844 LLVMValueRef Val, const char *Name);
845 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
846 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
848 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
849 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
850 LLVMValueRef *Indices, unsigned NumIndices,
852 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
853 LLVMValueRef *Indices, unsigned NumIndices,
855 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
856 unsigned Idx, const char *Name);
857 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
859 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
863 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
864 LLVMTypeRef DestTy, const char *Name);
865 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
866 LLVMTypeRef DestTy, const char *Name);
867 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
868 LLVMTypeRef DestTy, const char *Name);
869 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
870 LLVMTypeRef DestTy, const char *Name);
871 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
872 LLVMTypeRef DestTy, const char *Name);
873 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
874 LLVMTypeRef DestTy, const char *Name);
875 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
876 LLVMTypeRef DestTy, const char *Name);
877 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
878 LLVMTypeRef DestTy, const char *Name);
879 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
880 LLVMTypeRef DestTy, const char *Name);
881 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
882 LLVMTypeRef DestTy, const char *Name);
883 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
884 LLVMTypeRef DestTy, const char *Name);
885 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
886 LLVMTypeRef DestTy, const char *Name);
887 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
888 LLVMTypeRef DestTy, const char *Name);
889 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
890 LLVMTypeRef DestTy, const char *Name);
891 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
892 LLVMTypeRef DestTy, const char *Name);
893 LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
894 LLVMTypeRef DestTy, const char *Name);
895 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
896 LLVMTypeRef DestTy, const char *Name);
897 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/
898 LLVMTypeRef DestTy, const char *Name);
899 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
900 LLVMTypeRef DestTy, const char *Name);
903 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
904 LLVMValueRef LHS, LLVMValueRef RHS,
906 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
907 LLVMValueRef LHS, LLVMValueRef RHS,
910 /* Miscellaneous instructions */
911 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
912 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
913 LLVMValueRef *Args, unsigned NumArgs,
915 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
916 LLVMValueRef Then, LLVMValueRef Else,
918 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
920 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
921 LLVMValueRef Index, const char *Name);
922 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
923 LLVMValueRef EltVal, LLVMValueRef Index,
925 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
926 LLVMValueRef V2, LLVMValueRef Mask,
928 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
929 unsigned Index, const char *Name);
930 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
931 LLVMValueRef EltVal, unsigned Index,
934 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
936 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
938 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
939 LLVMValueRef RHS, const char *Name);
942 /*===-- Module providers --------------------------------------------------===*/
944 /* Changes the type of M so it can be passed to FunctionPassManagers and the
945 * JIT. They take ModuleProviders for historical reasons.
947 LLVMModuleProviderRef
948 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
950 /* Destroys the module M.
952 void LLVMDisposeModuleProvider(LLVMModuleProviderRef M);
955 /*===-- Memory buffers ----------------------------------------------------===*/
957 LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
958 LLVMMemoryBufferRef *OutMemBuf,
960 LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
962 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
965 /*===-- Pass Managers -----------------------------------------------------===*/
967 /** Constructs a new whole-module pass pipeline. This type of pipeline is
968 suitable for link-time optimization and whole-module transformations.
969 See llvm::PassManager::PassManager. */
970 LLVMPassManagerRef LLVMCreatePassManager(void);
972 /** Constructs a new function-by-function pass pipeline over the module
973 provider. It does not take ownership of the module provider. This type of
974 pipeline is suitable for code generation and JIT compilation tasks.
975 See llvm::FunctionPassManager::FunctionPassManager. */
976 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
978 /** Initializes, executes on the provided module, and finalizes all of the
979 passes scheduled in the pass manager. Returns 1 if any of the passes
980 modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */
981 LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
983 /** Initializes all of the function passes scheduled in the function pass
984 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
985 See llvm::FunctionPassManager::doInitialization. */
986 LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
988 /** Executes all of the function passes scheduled in the function pass manager
989 on the provided function. Returns 1 if any of the passes modified the
990 function, false otherwise.
991 See llvm::FunctionPassManager::run(Function&). */
992 LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
994 /** Finalizes all of the function passes scheduled in in the function pass
995 manager. Returns 1 if any of the passes modified the module, 0 otherwise.
996 See llvm::FunctionPassManager::doFinalization. */
997 LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
999 /** Frees the memory of a pass pipeline. For function pipelines, does not free
1000 the module provider.
1001 See llvm::PassManagerBase::~PassManagerBase. */
1002 void LLVMDisposePassManager(LLVMPassManagerRef PM);
1010 class PassManagerBase;
1012 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
1013 inline ty *unwrap(ref P) { \
1014 return reinterpret_cast<ty*>(P); \
1017 inline ref wrap(const ty *P) { \
1018 return reinterpret_cast<ref>(const_cast<ty*>(P)); \
1021 #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref) \
1022 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
1024 template<typename T> \
1025 inline T *unwrap(ref P) { \
1026 return cast<T>(unwrap(P)); \
1029 #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref) \
1030 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
1032 template<typename T> \
1033 inline T *unwrap(ref P) { \
1034 T *Q = (T*)unwrap(P); \
1035 assert(Q && "Invalid cast!"); \
1039 DEFINE_ISA_CONVERSION_FUNCTIONS (Type, LLVMTypeRef )
1040 DEFINE_ISA_CONVERSION_FUNCTIONS (Value, LLVMValueRef )
1041 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef )
1042 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef )
1043 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef )
1044 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder, LLVMTypeHandleRef )
1045 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef )
1046 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext, LLVMContextRef )
1047 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Use, LLVMUseIteratorRef )
1048 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef )
1049 /* LLVMModuleProviderRef exists for historical reasons, but now just holds a
1052 inline Module *unwrap(LLVMModuleProviderRef MP) {
1053 return reinterpret_cast<Module*>(MP);
1056 #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS
1057 #undef DEFINE_ISA_CONVERSION_FUNCTIONS
1058 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
1060 /* Specialized opaque context conversions.
1062 inline LLVMContext **unwrap(LLVMContextRef* Tys) {
1063 return reinterpret_cast<LLVMContext**>(Tys);
1066 inline LLVMContextRef *wrap(const LLVMContext **Tys) {
1067 return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys));
1070 /* Specialized opaque type conversions.
1072 inline Type **unwrap(LLVMTypeRef* Tys) {
1073 return reinterpret_cast<Type**>(Tys);
1076 inline LLVMTypeRef *wrap(const Type **Tys) {
1077 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
1080 /* Specialized opaque value conversions.
1082 inline Value **unwrap(LLVMValueRef *Vals) {
1083 return reinterpret_cast<Value**>(Vals);
1086 template<typename T>
1087 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
1089 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
1092 return reinterpret_cast<T**>(Vals);
1095 inline LLVMValueRef *wrap(const Value **Vals) {
1096 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
1100 #endif /* !defined(__cplusplus) */
1102 #endif /* !defined(LLVM_C_CORE_H) */