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