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