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