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