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