Core.h revision 218893
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 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); 325const char *LLVMGetTypeName(LLVMModuleRef M, LLVMTypeRef Ty); 326 327/** See Module::dump. */ 328void LLVMDumpModule(LLVMModuleRef M); 329 330/** See Module::setModuleInlineAsm. */ 331void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm); 332 333/** See Module::getContext. */ 334LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M); 335 336/*===-- Types -------------------------------------------------------------===*/ 337 338/* LLVM types conform to the following hierarchy: 339 * 340 * types: 341 * integer type 342 * real type 343 * function type 344 * sequence types: 345 * array type 346 * pointer type 347 * vector type 348 * void type 349 * label type 350 * opaque type 351 */ 352 353/** See llvm::LLVMTypeKind::getTypeID. */ 354LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty); 355 356/** See llvm::LLVMType::getContext. */ 357LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty); 358 359/* Operations on integer types */ 360LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C); 361LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C); 362LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C); 363LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C); 364LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C); 365LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits); 366 367LLVMTypeRef LLVMInt1Type(void); 368LLVMTypeRef LLVMInt8Type(void); 369LLVMTypeRef LLVMInt16Type(void); 370LLVMTypeRef LLVMInt32Type(void); 371LLVMTypeRef LLVMInt64Type(void); 372LLVMTypeRef LLVMIntType(unsigned NumBits); 373unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy); 374 375/* Operations on real types */ 376LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C); 377LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C); 378LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C); 379LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C); 380LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C); 381 382LLVMTypeRef LLVMFloatType(void); 383LLVMTypeRef LLVMDoubleType(void); 384LLVMTypeRef LLVMX86FP80Type(void); 385LLVMTypeRef LLVMFP128Type(void); 386LLVMTypeRef LLVMPPCFP128Type(void); 387 388/* Operations on function types */ 389LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType, 390 LLVMTypeRef *ParamTypes, unsigned ParamCount, 391 LLVMBool IsVarArg); 392LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy); 393LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy); 394unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy); 395void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest); 396 397/* Operations on struct types */ 398LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes, 399 unsigned ElementCount, LLVMBool Packed); 400LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount, 401 LLVMBool Packed); 402unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy); 403void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest); 404LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy); 405 406/* Operations on array, pointer, and vector types (sequence types) */ 407LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount); 408LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace); 409LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount); 410 411LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty); 412unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy); 413unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy); 414unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy); 415 416/* Operations on other types */ 417LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C); 418LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C); 419LLVMTypeRef LLVMOpaqueTypeInContext(LLVMContextRef C); 420LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C); 421 422LLVMTypeRef LLVMVoidType(void); 423LLVMTypeRef LLVMLabelType(void); 424LLVMTypeRef LLVMOpaqueType(void); 425LLVMTypeRef LLVMX86MMXType(void); 426 427/* Operations on type handles */ 428LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy); 429void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy); 430LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle); 431void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle); 432 433 434/*===-- Values ------------------------------------------------------------===*/ 435 436/* The bulk of LLVM's object model consists of values, which comprise a very 437 * rich type hierarchy. 438 */ 439 440#define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \ 441 macro(Argument) \ 442 macro(BasicBlock) \ 443 macro(InlineAsm) \ 444 macro(User) \ 445 macro(Constant) \ 446 macro(ConstantAggregateZero) \ 447 macro(ConstantArray) \ 448 macro(ConstantExpr) \ 449 macro(ConstantFP) \ 450 macro(ConstantInt) \ 451 macro(ConstantPointerNull) \ 452 macro(ConstantStruct) \ 453 macro(ConstantVector) \ 454 macro(GlobalValue) \ 455 macro(Function) \ 456 macro(GlobalAlias) \ 457 macro(GlobalVariable) \ 458 macro(UndefValue) \ 459 macro(Instruction) \ 460 macro(BinaryOperator) \ 461 macro(CallInst) \ 462 macro(IntrinsicInst) \ 463 macro(DbgInfoIntrinsic) \ 464 macro(DbgDeclareInst) \ 465 macro(EHSelectorInst) \ 466 macro(MemIntrinsic) \ 467 macro(MemCpyInst) \ 468 macro(MemMoveInst) \ 469 macro(MemSetInst) \ 470 macro(CmpInst) \ 471 macro(FCmpInst) \ 472 macro(ICmpInst) \ 473 macro(ExtractElementInst) \ 474 macro(GetElementPtrInst) \ 475 macro(InsertElementInst) \ 476 macro(InsertValueInst) \ 477 macro(PHINode) \ 478 macro(SelectInst) \ 479 macro(ShuffleVectorInst) \ 480 macro(StoreInst) \ 481 macro(TerminatorInst) \ 482 macro(BranchInst) \ 483 macro(InvokeInst) \ 484 macro(ReturnInst) \ 485 macro(SwitchInst) \ 486 macro(UnreachableInst) \ 487 macro(UnwindInst) \ 488 macro(UnaryInstruction) \ 489 macro(AllocaInst) \ 490 macro(CastInst) \ 491 macro(BitCastInst) \ 492 macro(FPExtInst) \ 493 macro(FPToSIInst) \ 494 macro(FPToUIInst) \ 495 macro(FPTruncInst) \ 496 macro(IntToPtrInst) \ 497 macro(PtrToIntInst) \ 498 macro(SExtInst) \ 499 macro(SIToFPInst) \ 500 macro(TruncInst) \ 501 macro(UIToFPInst) \ 502 macro(ZExtInst) \ 503 macro(ExtractValueInst) \ 504 macro(LoadInst) \ 505 macro(VAArgInst) 506 507/* Operations on all values */ 508LLVMTypeRef LLVMTypeOf(LLVMValueRef Val); 509const char *LLVMGetValueName(LLVMValueRef Val); 510void LLVMSetValueName(LLVMValueRef Val, const char *Name); 511void LLVMDumpValue(LLVMValueRef Val); 512void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal); 513int LLVMHasMetadata(LLVMValueRef Val); 514LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID); 515void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node); 516 517/* Conversion functions. Return the input value if it is an instance of the 518 specified class, otherwise NULL. See llvm::dyn_cast_or_null<>. */ 519#define LLVM_DECLARE_VALUE_CAST(name) \ 520 LLVMValueRef LLVMIsA##name(LLVMValueRef Val); 521LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST) 522 523/* Operations on Uses */ 524LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val); 525LLVMUseRef LLVMGetNextUse(LLVMUseRef U); 526LLVMValueRef LLVMGetUser(LLVMUseRef U); 527LLVMValueRef LLVMGetUsedValue(LLVMUseRef U); 528 529/* Operations on Users */ 530LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index); 531void LLVMSetOperand(LLVMValueRef User, unsigned Index, LLVMValueRef Val); 532int LLVMGetNumOperands(LLVMValueRef Val); 533 534/* Operations on constants of any type */ 535LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */ 536LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */ 537LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty); 538LLVMBool LLVMIsConstant(LLVMValueRef Val); 539LLVMBool LLVMIsNull(LLVMValueRef Val); 540LLVMBool LLVMIsUndef(LLVMValueRef Val); 541LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty); 542 543/* Operations on metadata */ 544LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str, 545 unsigned SLen); 546LLVMValueRef LLVMMDString(const char *Str, unsigned SLen); 547LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals, 548 unsigned Count); 549LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count); 550 551/* Operations on scalar constants */ 552LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N, 553 LLVMBool SignExtend); 554LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy, 555 unsigned NumWords, 556 const uint64_t Words[]); 557LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text, 558 uint8_t Radix); 559LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text, 560 unsigned SLen, uint8_t Radix); 561LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N); 562LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text); 563LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text, 564 unsigned SLen); 565unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal); 566long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal); 567 568 569/* Operations on composite constants */ 570LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str, 571 unsigned Length, LLVMBool DontNullTerminate); 572LLVMValueRef LLVMConstStructInContext(LLVMContextRef C, 573 LLVMValueRef *ConstantVals, 574 unsigned Count, LLVMBool Packed); 575 576LLVMValueRef LLVMConstString(const char *Str, unsigned Length, 577 LLVMBool DontNullTerminate); 578LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy, 579 LLVMValueRef *ConstantVals, unsigned Length); 580LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count, 581 LLVMBool Packed); 582LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size); 583 584/* Constant expressions */ 585LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal); 586LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty); 587LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty); 588LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal); 589LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal); 590LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal); 591LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal); 592LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal); 593LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 594LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 595LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 596LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 597LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 598LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 599LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 600LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 601LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 602LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 603LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 604LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 605LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 606LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 607LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 608LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 609LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 610LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 611LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 612LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 613LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 614LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 615LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, 616 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 617LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, 618 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 619LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 620LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 621LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 622LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, 623 LLVMValueRef *ConstantIndices, unsigned NumIndices); 624LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal, 625 LLVMValueRef *ConstantIndices, 626 unsigned NumIndices); 627LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 628LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 629LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 630LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 631LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 632LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 633LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 634LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 635LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 636LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 637LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 638LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 639LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal, 640 LLVMTypeRef ToType); 641LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal, 642 LLVMTypeRef ToType); 643LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal, 644 LLVMTypeRef ToType); 645LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal, 646 LLVMTypeRef ToType); 647LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType, 648 LLVMBool isSigned); 649LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 650LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, 651 LLVMValueRef ConstantIfTrue, 652 LLVMValueRef ConstantIfFalse); 653LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, 654 LLVMValueRef IndexConstant); 655LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, 656 LLVMValueRef ElementValueConstant, 657 LLVMValueRef IndexConstant); 658LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, 659 LLVMValueRef VectorBConstant, 660 LLVMValueRef MaskConstant); 661LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList, 662 unsigned NumIdx); 663LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, 664 LLVMValueRef ElementValueConstant, 665 unsigned *IdxList, unsigned NumIdx); 666LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, 667 const char *AsmString, const char *Constraints, 668 LLVMBool HasSideEffects, LLVMBool IsAlignStack); 669LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB); 670 671/* Operations on global variables, functions, and aliases (globals) */ 672LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global); 673LLVMBool LLVMIsDeclaration(LLVMValueRef Global); 674LLVMLinkage LLVMGetLinkage(LLVMValueRef Global); 675void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage); 676const char *LLVMGetSection(LLVMValueRef Global); 677void LLVMSetSection(LLVMValueRef Global, const char *Section); 678LLVMVisibility LLVMGetVisibility(LLVMValueRef Global); 679void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz); 680unsigned LLVMGetAlignment(LLVMValueRef Global); 681void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes); 682 683/* Operations on global variables */ 684LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name); 685LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty, 686 const char *Name, 687 unsigned AddressSpace); 688LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name); 689LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M); 690LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M); 691LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar); 692LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar); 693void LLVMDeleteGlobal(LLVMValueRef GlobalVar); 694LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar); 695void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal); 696LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar); 697void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal); 698LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar); 699void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant); 700 701/* Operations on aliases */ 702LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee, 703 const char *Name); 704 705/* Operations on functions */ 706LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name, 707 LLVMTypeRef FunctionTy); 708LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name); 709LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M); 710LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M); 711LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn); 712LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn); 713void LLVMDeleteFunction(LLVMValueRef Fn); 714unsigned LLVMGetIntrinsicID(LLVMValueRef Fn); 715unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn); 716void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC); 717const char *LLVMGetGC(LLVMValueRef Fn); 718void LLVMSetGC(LLVMValueRef Fn, const char *Name); 719void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA); 720LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn); 721void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA); 722 723/* Operations on parameters */ 724unsigned LLVMCountParams(LLVMValueRef Fn); 725void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params); 726LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index); 727LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst); 728LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn); 729LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn); 730LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg); 731LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg); 732void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA); 733void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA); 734LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg); 735void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align); 736 737/* Operations on basic blocks */ 738LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB); 739LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val); 740LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val); 741LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB); 742unsigned LLVMCountBasicBlocks(LLVMValueRef Fn); 743void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks); 744LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn); 745LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn); 746LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB); 747LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB); 748LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn); 749 750LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C, 751 LLVMValueRef Fn, 752 const char *Name); 753LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C, 754 LLVMBasicBlockRef BB, 755 const char *Name); 756 757LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name); 758LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB, 759 const char *Name); 760void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB); 761 762void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos); 763void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos); 764 765/* Operations on instructions */ 766LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst); 767LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB); 768LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB); 769LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst); 770LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst); 771 772/* Operations on call sites */ 773void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC); 774unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr); 775void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute); 776void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index, 777 LLVMAttribute); 778void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index, 779 unsigned align); 780 781/* Operations on call instructions (only) */ 782LLVMBool LLVMIsTailCall(LLVMValueRef CallInst); 783void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall); 784 785/* Operations on phi nodes */ 786void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues, 787 LLVMBasicBlockRef *IncomingBlocks, unsigned Count); 788unsigned LLVMCountIncoming(LLVMValueRef PhiNode); 789LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index); 790LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index); 791 792/*===-- Instruction builders ----------------------------------------------===*/ 793 794/* An instruction builder represents a point within a basic block, and is the 795 * exclusive means of building instructions using the C interface. 796 */ 797 798LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C); 799LLVMBuilderRef LLVMCreateBuilder(void); 800void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block, 801 LLVMValueRef Instr); 802void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr); 803void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block); 804LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder); 805void LLVMClearInsertionPosition(LLVMBuilderRef Builder); 806void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr); 807void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr, 808 const char *Name); 809void LLVMDisposeBuilder(LLVMBuilderRef Builder); 810 811/* Metadata */ 812void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L); 813LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder); 814void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst); 815 816/* Terminators */ 817LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef); 818LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V); 819LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals, 820 unsigned N); 821LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest); 822LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If, 823 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else); 824LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V, 825 LLVMBasicBlockRef Else, unsigned NumCases); 826LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr, 827 unsigned NumDests); 828LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn, 829 LLVMValueRef *Args, unsigned NumArgs, 830 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, 831 const char *Name); 832LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef); 833LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef); 834 835/* Add a case to the switch instruction */ 836void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal, 837 LLVMBasicBlockRef Dest); 838 839/* Add a destination to the indirectbr instruction */ 840void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest); 841 842/* Arithmetic */ 843LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 844 const char *Name); 845LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 846 const char *Name); 847LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 848 const char *Name); 849LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 850 const char *Name); 851LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 852 const char *Name); 853LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 854 const char *Name); 855LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 856 const char *Name); 857LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 858 const char *Name); 859LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 860 const char *Name); 861LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 862 const char *Name); 863LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 864 const char *Name); 865LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 866 const char *Name); 867LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 868 const char *Name); 869LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 870 const char *Name); 871LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 872 const char *Name); 873LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 874 const char *Name); 875LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 876 const char *Name); 877LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 878 const char *Name); 879LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 880 const char *Name); 881LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 882 const char *Name); 883LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 884 const char *Name); 885LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 886 const char *Name); 887LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 888 const char *Name); 889LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 890 const char *Name); 891LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 892 const char *Name); 893LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op, 894 LLVMValueRef LHS, LLVMValueRef RHS, 895 const char *Name); 896LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name); 897LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V, 898 const char *Name); 899LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V, 900 const char *Name); 901LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name); 902LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name); 903 904/* Memory */ 905LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 906LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty, 907 LLVMValueRef Val, const char *Name); 908LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 909LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty, 910 LLVMValueRef Val, const char *Name); 911LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal); 912LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal, 913 const char *Name); 914LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr); 915LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 916 LLVMValueRef *Indices, unsigned NumIndices, 917 const char *Name); 918LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 919 LLVMValueRef *Indices, unsigned NumIndices, 920 const char *Name); 921LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 922 unsigned Idx, const char *Name); 923LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str, 924 const char *Name); 925LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str, 926 const char *Name); 927 928/* Casts */ 929LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val, 930 LLVMTypeRef DestTy, const char *Name); 931LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val, 932 LLVMTypeRef DestTy, const char *Name); 933LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val, 934 LLVMTypeRef DestTy, const char *Name); 935LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val, 936 LLVMTypeRef DestTy, const char *Name); 937LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val, 938 LLVMTypeRef DestTy, const char *Name); 939LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val, 940 LLVMTypeRef DestTy, const char *Name); 941LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val, 942 LLVMTypeRef DestTy, const char *Name); 943LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val, 944 LLVMTypeRef DestTy, const char *Name); 945LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val, 946 LLVMTypeRef DestTy, const char *Name); 947LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val, 948 LLVMTypeRef DestTy, const char *Name); 949LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val, 950 LLVMTypeRef DestTy, const char *Name); 951LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val, 952 LLVMTypeRef DestTy, const char *Name); 953LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 954 LLVMTypeRef DestTy, const char *Name); 955LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 956 LLVMTypeRef DestTy, const char *Name); 957LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 958 LLVMTypeRef DestTy, const char *Name); 959LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val, 960 LLVMTypeRef DestTy, const char *Name); 961LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val, 962 LLVMTypeRef DestTy, const char *Name); 963LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/ 964 LLVMTypeRef DestTy, const char *Name); 965LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val, 966 LLVMTypeRef DestTy, const char *Name); 967 968/* Comparisons */ 969LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op, 970 LLVMValueRef LHS, LLVMValueRef RHS, 971 const char *Name); 972LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op, 973 LLVMValueRef LHS, LLVMValueRef RHS, 974 const char *Name); 975 976/* Miscellaneous instructions */ 977LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 978LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn, 979 LLVMValueRef *Args, unsigned NumArgs, 980 const char *Name); 981LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If, 982 LLVMValueRef Then, LLVMValueRef Else, 983 const char *Name); 984LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty, 985 const char *Name); 986LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal, 987 LLVMValueRef Index, const char *Name); 988LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal, 989 LLVMValueRef EltVal, LLVMValueRef Index, 990 const char *Name); 991LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1, 992 LLVMValueRef V2, LLVMValueRef Mask, 993 const char *Name); 994LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal, 995 unsigned Index, const char *Name); 996LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal, 997 LLVMValueRef EltVal, unsigned Index, 998 const char *Name); 999 1000LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val, 1001 const char *Name); 1002LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val, 1003 const char *Name); 1004LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS, 1005 LLVMValueRef RHS, const char *Name); 1006 1007 1008/*===-- Module providers --------------------------------------------------===*/ 1009 1010/* Changes the type of M so it can be passed to FunctionPassManagers and the 1011 * JIT. They take ModuleProviders for historical reasons. 1012 */ 1013LLVMModuleProviderRef 1014LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M); 1015 1016/* Destroys the module M. 1017 */ 1018void LLVMDisposeModuleProvider(LLVMModuleProviderRef M); 1019 1020 1021/*===-- Memory buffers ----------------------------------------------------===*/ 1022 1023LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path, 1024 LLVMMemoryBufferRef *OutMemBuf, 1025 char **OutMessage); 1026LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf, 1027 char **OutMessage); 1028void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf); 1029 1030/*===-- Pass Registry -----------------------------------------------------===*/ 1031 1032/** Return the global pass registry, for use with initialization functions. 1033 See llvm::PassRegistry::getPassRegistry. */ 1034LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void); 1035 1036/*===-- Pass Managers -----------------------------------------------------===*/ 1037 1038/** Constructs a new whole-module pass pipeline. This type of pipeline is 1039 suitable for link-time optimization and whole-module transformations. 1040 See llvm::PassManager::PassManager. */ 1041LLVMPassManagerRef LLVMCreatePassManager(void); 1042 1043/** Constructs a new function-by-function pass pipeline over the module 1044 provider. It does not take ownership of the module provider. This type of 1045 pipeline is suitable for code generation and JIT compilation tasks. 1046 See llvm::FunctionPassManager::FunctionPassManager. */ 1047LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M); 1048 1049/** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */ 1050LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP); 1051 1052/** Initializes, executes on the provided module, and finalizes all of the 1053 passes scheduled in the pass manager. Returns 1 if any of the passes 1054 modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */ 1055LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M); 1056 1057/** Initializes all of the function passes scheduled in the function pass 1058 manager. Returns 1 if any of the passes modified the module, 0 otherwise. 1059 See llvm::FunctionPassManager::doInitialization. */ 1060LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM); 1061 1062/** Executes all of the function passes scheduled in the function pass manager 1063 on the provided function. Returns 1 if any of the passes modified the 1064 function, false otherwise. 1065 See llvm::FunctionPassManager::run(Function&). */ 1066LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F); 1067 1068/** Finalizes all of the function passes scheduled in in the function pass 1069 manager. Returns 1 if any of the passes modified the module, 0 otherwise. 1070 See llvm::FunctionPassManager::doFinalization. */ 1071LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM); 1072 1073/** Frees the memory of a pass pipeline. For function pipelines, does not free 1074 the module provider. 1075 See llvm::PassManagerBase::~PassManagerBase. */ 1076void LLVMDisposePassManager(LLVMPassManagerRef PM); 1077 1078 1079#ifdef __cplusplus 1080} 1081 1082namespace llvm { 1083 class MemoryBuffer; 1084 class PassManagerBase; 1085 1086 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \ 1087 inline ty *unwrap(ref P) { \ 1088 return reinterpret_cast<ty*>(P); \ 1089 } \ 1090 \ 1091 inline ref wrap(const ty *P) { \ 1092 return reinterpret_cast<ref>(const_cast<ty*>(P)); \ 1093 } 1094 1095 #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref) \ 1096 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \ 1097 \ 1098 template<typename T> \ 1099 inline T *unwrap(ref P) { \ 1100 return cast<T>(unwrap(P)); \ 1101 } 1102 1103 #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref) \ 1104 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \ 1105 \ 1106 template<typename T> \ 1107 inline T *unwrap(ref P) { \ 1108 T *Q = (T*)unwrap(P); \ 1109 assert(Q && "Invalid cast!"); \ 1110 return Q; \ 1111 } 1112 1113 DEFINE_ISA_CONVERSION_FUNCTIONS (Type, LLVMTypeRef ) 1114 DEFINE_ISA_CONVERSION_FUNCTIONS (Value, LLVMValueRef ) 1115 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef ) 1116 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef ) 1117 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef ) 1118 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder, LLVMTypeHandleRef ) 1119 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef ) 1120 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext, LLVMContextRef ) 1121 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Use, LLVMUseRef ) 1122 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef ) 1123 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassRegistry, LLVMPassRegistryRef ) 1124 /* LLVMModuleProviderRef exists for historical reasons, but now just holds a 1125 * Module. 1126 */ 1127 inline Module *unwrap(LLVMModuleProviderRef MP) { 1128 return reinterpret_cast<Module*>(MP); 1129 } 1130 1131 #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS 1132 #undef DEFINE_ISA_CONVERSION_FUNCTIONS 1133 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS 1134 1135 /* Specialized opaque context conversions. 1136 */ 1137 inline LLVMContext **unwrap(LLVMContextRef* Tys) { 1138 return reinterpret_cast<LLVMContext**>(Tys); 1139 } 1140 1141 inline LLVMContextRef *wrap(const LLVMContext **Tys) { 1142 return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys)); 1143 } 1144 1145 /* Specialized opaque type conversions. 1146 */ 1147 inline Type **unwrap(LLVMTypeRef* Tys) { 1148 return reinterpret_cast<Type**>(Tys); 1149 } 1150 1151 inline LLVMTypeRef *wrap(const Type **Tys) { 1152 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys)); 1153 } 1154 1155 /* Specialized opaque value conversions. 1156 */ 1157 inline Value **unwrap(LLVMValueRef *Vals) { 1158 return reinterpret_cast<Value**>(Vals); 1159 } 1160 1161 template<typename T> 1162 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) { 1163 #if DEBUG 1164 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I) 1165 cast<T>(*I); 1166 #endif 1167 return reinterpret_cast<T**>(Vals); 1168 } 1169 1170 inline LLVMValueRef *wrap(const Value **Vals) { 1171 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals)); 1172 } 1173} 1174 1175#endif /* !defined(__cplusplus) */ 1176 1177#endif /* !defined(LLVM_C_CORE_H) */ 1178