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