Core.h revision e56a94ef91009ddb8d8b68783ff1650bcad3b326
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/Support/IRBuilder.h" 44 45extern "C" { 46#endif 47 48 49/* Opaque types. */ 50 51/** 52 * The top-level container for all LLVM global data. See the LLVMContext class. 53 */ 54typedef struct LLVMOpaqueContext *LLVMContextRef; 55 56/** 57 * The top-level container for all other LLVM Intermediate Representation (IR) 58 * objects. See the llvm::Module class. 59 */ 60typedef struct LLVMOpaqueModule *LLVMModuleRef; 61 62/** 63 * Each value in the LLVM IR has a type, an LLVMTypeRef. See the llvm::Type 64 * class. 65 */ 66typedef struct LLVMOpaqueType *LLVMTypeRef; 67 68/** 69 * When building recursive types using LLVMRefineType, LLVMTypeRef values may 70 * become invalid; use LLVMTypeHandleRef to resolve this problem. See the 71 * llvm::AbstractTypeHolder class. 72 */ 73typedef struct LLVMOpaqueTypeHandle *LLVMTypeHandleRef; 74 75typedef struct LLVMOpaqueValue *LLVMValueRef; 76typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef; 77typedef struct LLVMOpaqueBuilder *LLVMBuilderRef; 78 79/* Used to provide a module to JIT or interpreter. 80 * See the llvm::ModuleProvider class. 81 */ 82typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef; 83 84/* Used to provide a module to JIT or interpreter. 85 * See the llvm::MemoryBuffer class. 86 */ 87typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef; 88 89/** See the llvm::PassManagerBase class. */ 90typedef struct LLVMOpaquePassManager *LLVMPassManagerRef; 91 92typedef enum { 93 LLVMZExtAttribute = 1<<0, 94 LLVMSExtAttribute = 1<<1, 95 LLVMNoReturnAttribute = 1<<2, 96 LLVMInRegAttribute = 1<<3, 97 LLVMStructRetAttribute = 1<<4, 98 LLVMNoUnwindAttribute = 1<<5, 99 LLVMNoAliasAttribute = 1<<6, 100 LLVMByValAttribute = 1<<7, 101 LLVMNestAttribute = 1<<8, 102 LLVMReadNoneAttribute = 1<<9, 103 LLVMReadOnlyAttribute = 1<<10, 104 LLVMNoInlineAttribute = 1<<11, 105 LLVMAlwaysInlineAttribute = 1<<12, 106 LLVMOptimizeForSizeAttribute = 1<<13, 107 LLVMStackProtectAttribute = 1<<14, 108 LLVMStackProtectReqAttribute = 1<<15, 109 LLVMNoCaptureAttribute = 1<<21, 110 LLVMNoRedZoneAttribute = 1<<22, 111 LLVMNoImplicitFloatAttribute = 1<<23, 112 LLVMNakedAttribute = 1<<24, 113 LLVMInlineHintAttribute = 1<<25 114} LLVMAttribute; 115 116typedef enum { 117 LLVMVoidTypeKind, /**< type with no size */ 118 LLVMFloatTypeKind, /**< 32 bit floating point type */ 119 LLVMDoubleTypeKind, /**< 64 bit floating point type */ 120 LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */ 121 LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/ 122 LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */ 123 LLVMLabelTypeKind, /**< Labels */ 124 LLVMIntegerTypeKind, /**< Arbitrary bit width integers */ 125 LLVMFunctionTypeKind, /**< Functions */ 126 LLVMStructTypeKind, /**< Structures */ 127 LLVMArrayTypeKind, /**< Arrays */ 128 LLVMPointerTypeKind, /**< Pointers */ 129 LLVMOpaqueTypeKind, /**< Opaque: type with unknown structure */ 130 LLVMVectorTypeKind, /**< SIMD 'packed' format, or other vector type */ 131 LLVMMetadataTypeKind /**< Metadata */ 132} LLVMTypeKind; 133 134typedef enum { 135 LLVMExternalLinkage, /**< Externally visible function */ 136 LLVMAvailableExternallyLinkage, 137 LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/ 138 LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something 139 equivalent. */ 140 LLVMWeakAnyLinkage, /**< Keep one copy of function when linking (weak) */ 141 LLVMWeakODRLinkage, /**< Same, but only replaced by something 142 equivalent. */ 143 LLVMAppendingLinkage, /**< Special purpose, only applies to global arrays */ 144 LLVMInternalLinkage, /**< Rename collisions when linking (static 145 functions) */ 146 LLVMPrivateLinkage, /**< Like Internal, but omit from symbol table */ 147 LLVMDLLImportLinkage, /**< Function to be imported from DLL */ 148 LLVMDLLExportLinkage, /**< Function to be accessible from DLL */ 149 LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */ 150 LLVMGhostLinkage, /**< Stand-in functions for streaming fns from 151 bitcode */ 152 LLVMCommonLinkage, /**< Tentative definitions */ 153 LLVMLinkerPrivateLinkage /**< Like Private, but linker removes. */ 154} LLVMLinkage; 155 156typedef enum { 157 LLVMDefaultVisibility, /**< The GV is visible */ 158 LLVMHiddenVisibility, /**< The GV is hidden */ 159 LLVMProtectedVisibility /**< The GV is protected */ 160} LLVMVisibility; 161 162typedef enum { 163 LLVMCCallConv = 0, 164 LLVMFastCallConv = 8, 165 LLVMColdCallConv = 9, 166 LLVMX86StdcallCallConv = 64, 167 LLVMX86FastcallCallConv = 65 168} LLVMCallConv; 169 170typedef enum { 171 LLVMIntEQ = 32, /**< equal */ 172 LLVMIntNE, /**< not equal */ 173 LLVMIntUGT, /**< unsigned greater than */ 174 LLVMIntUGE, /**< unsigned greater or equal */ 175 LLVMIntULT, /**< unsigned less than */ 176 LLVMIntULE, /**< unsigned less or equal */ 177 LLVMIntSGT, /**< signed greater than */ 178 LLVMIntSGE, /**< signed greater or equal */ 179 LLVMIntSLT, /**< signed less than */ 180 LLVMIntSLE /**< signed less or equal */ 181} LLVMIntPredicate; 182 183typedef enum { 184 LLVMRealPredicateFalse, /**< Always false (always folded) */ 185 LLVMRealOEQ, /**< True if ordered and equal */ 186 LLVMRealOGT, /**< True if ordered and greater than */ 187 LLVMRealOGE, /**< True if ordered and greater than or equal */ 188 LLVMRealOLT, /**< True if ordered and less than */ 189 LLVMRealOLE, /**< True if ordered and less than or equal */ 190 LLVMRealONE, /**< True if ordered and operands are unequal */ 191 LLVMRealORD, /**< True if ordered (no nans) */ 192 LLVMRealUNO, /**< True if unordered: isnan(X) | isnan(Y) */ 193 LLVMRealUEQ, /**< True if unordered or equal */ 194 LLVMRealUGT, /**< True if unordered or greater than */ 195 LLVMRealUGE, /**< True if unordered, greater than, or equal */ 196 LLVMRealULT, /**< True if unordered or less than */ 197 LLVMRealULE, /**< True if unordered, less than, or equal */ 198 LLVMRealUNE, /**< True if unordered or not equal */ 199 LLVMRealPredicateTrue /**< Always true (always folded) */ 200} LLVMRealPredicate; 201 202 203/*===-- Error handling ----------------------------------------------------===*/ 204 205void LLVMDisposeMessage(char *Message); 206 207 208/*===-- Modules -----------------------------------------------------------===*/ 209 210/* Create and destroy contexts. */ 211LLVMContextRef LLVMContextCreate(void); 212LLVMContextRef LLVMGetGlobalContext(void); 213void LLVMContextDispose(LLVMContextRef C); 214 215/* Create and destroy modules. */ 216/** See llvm::Module::Module. */ 217LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID); 218LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID, 219 LLVMContextRef C); 220 221/** See llvm::Module::~Module. */ 222void LLVMDisposeModule(LLVMModuleRef M); 223 224/** Data layout. See Module::getDataLayout. */ 225const char *LLVMGetDataLayout(LLVMModuleRef M); 226void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple); 227 228/** Target triple. See Module::getTargetTriple. */ 229const char *LLVMGetTarget(LLVMModuleRef M); 230void LLVMSetTarget(LLVMModuleRef M, const char *Triple); 231 232/** See Module::addTypeName. */ 233int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty); 234void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name); 235LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name); 236 237/** See Module::dump. */ 238void LLVMDumpModule(LLVMModuleRef M); 239 240 241/*===-- Types -------------------------------------------------------------===*/ 242 243/* LLVM types conform to the following hierarchy: 244 * 245 * types: 246 * integer type 247 * real type 248 * function type 249 * sequence types: 250 * array type 251 * pointer type 252 * vector type 253 * void type 254 * label type 255 * opaque type 256 */ 257 258/** See llvm::LLVMTypeKind::getTypeID. */ 259LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty); 260 261/** See llvm::LLVMType::getContext. */ 262LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty); 263 264/* Operations on integer types */ 265LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C); 266LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C); 267LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C); 268LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C); 269LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C); 270LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits); 271 272LLVMTypeRef LLVMInt1Type(void); 273LLVMTypeRef LLVMInt8Type(void); 274LLVMTypeRef LLVMInt16Type(void); 275LLVMTypeRef LLVMInt32Type(void); 276LLVMTypeRef LLVMInt64Type(void); 277LLVMTypeRef LLVMIntType(unsigned NumBits); 278unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy); 279 280/* Operations on real types */ 281LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C); 282LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C); 283LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C); 284LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C); 285LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C); 286 287LLVMTypeRef LLVMFloatType(void); 288LLVMTypeRef LLVMDoubleType(void); 289LLVMTypeRef LLVMX86FP80Type(void); 290LLVMTypeRef LLVMFP128Type(void); 291LLVMTypeRef LLVMPPCFP128Type(void); 292 293/* Operations on function types */ 294LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType, 295 LLVMTypeRef *ParamTypes, unsigned ParamCount, 296 int IsVarArg); 297int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy); 298LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy); 299unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy); 300void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest); 301 302/* Operations on struct types */ 303LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes, 304 unsigned ElementCount, int Packed); 305LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount, 306 int Packed); 307unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy); 308void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest); 309int LLVMIsPackedStruct(LLVMTypeRef StructTy); 310 311/* Operations on array, pointer, and vector types (sequence types) */ 312LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount); 313LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace); 314LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount); 315 316LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty); 317unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy); 318unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy); 319unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy); 320 321/* Operations on other types */ 322LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C); 323LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C); 324LLVMTypeRef LLVMOpaqueTypeInContext(LLVMContextRef C); 325 326LLVMTypeRef LLVMVoidType(void); 327LLVMTypeRef LLVMLabelType(void); 328LLVMTypeRef LLVMOpaqueType(void); 329 330/* Operations on type handles */ 331LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy); 332void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy); 333LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle); 334void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle); 335 336 337/*===-- Values ------------------------------------------------------------===*/ 338 339/* The bulk of LLVM's object model consists of values, which comprise a very 340 * rich type hierarchy. 341 */ 342 343#define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \ 344 macro(Argument) \ 345 macro(BasicBlock) \ 346 macro(InlineAsm) \ 347 macro(User) \ 348 macro(Constant) \ 349 macro(ConstantAggregateZero) \ 350 macro(ConstantArray) \ 351 macro(ConstantExpr) \ 352 macro(ConstantFP) \ 353 macro(ConstantInt) \ 354 macro(ConstantPointerNull) \ 355 macro(ConstantStruct) \ 356 macro(ConstantVector) \ 357 macro(GlobalValue) \ 358 macro(Function) \ 359 macro(GlobalAlias) \ 360 macro(GlobalVariable) \ 361 macro(UndefValue) \ 362 macro(Instruction) \ 363 macro(BinaryOperator) \ 364 macro(CallInst) \ 365 macro(IntrinsicInst) \ 366 macro(DbgInfoIntrinsic) \ 367 macro(DbgDeclareInst) \ 368 macro(DbgFuncStartInst) \ 369 macro(DbgRegionEndInst) \ 370 macro(DbgRegionStartInst) \ 371 macro(DbgStopPointInst) \ 372 macro(EHSelectorInst) \ 373 macro(MemIntrinsic) \ 374 macro(MemCpyInst) \ 375 macro(MemMoveInst) \ 376 macro(MemSetInst) \ 377 macro(CmpInst) \ 378 macro(FCmpInst) \ 379 macro(ICmpInst) \ 380 macro(ExtractElementInst) \ 381 macro(GetElementPtrInst) \ 382 macro(InsertElementInst) \ 383 macro(InsertValueInst) \ 384 macro(PHINode) \ 385 macro(SelectInst) \ 386 macro(ShuffleVectorInst) \ 387 macro(StoreInst) \ 388 macro(TerminatorInst) \ 389 macro(BranchInst) \ 390 macro(InvokeInst) \ 391 macro(ReturnInst) \ 392 macro(SwitchInst) \ 393 macro(UnreachableInst) \ 394 macro(UnwindInst) \ 395 macro(UnaryInstruction) \ 396 macro(AllocationInst) \ 397 macro(AllocaInst) \ 398 macro(MallocInst) \ 399 macro(CastInst) \ 400 macro(BitCastInst) \ 401 macro(FPExtInst) \ 402 macro(FPToSIInst) \ 403 macro(FPToUIInst) \ 404 macro(FPTruncInst) \ 405 macro(IntToPtrInst) \ 406 macro(PtrToIntInst) \ 407 macro(SExtInst) \ 408 macro(SIToFPInst) \ 409 macro(TruncInst) \ 410 macro(UIToFPInst) \ 411 macro(ZExtInst) \ 412 macro(ExtractValueInst) \ 413 macro(FreeInst) \ 414 macro(LoadInst) \ 415 macro(VAArgInst) 416 417/* Operations on all values */ 418LLVMTypeRef LLVMTypeOf(LLVMValueRef Val); 419const char *LLVMGetValueName(LLVMValueRef Val); 420void LLVMSetValueName(LLVMValueRef Val, const char *Name); 421void LLVMDumpValue(LLVMValueRef Val); 422 423/* Conversion functions. Return the input value if it is an instance of the 424 specified class, otherwise NULL. See llvm::dyn_cast_or_null<>. */ 425#define LLVM_DECLARE_VALUE_CAST(name) \ 426 LLVMValueRef LLVMIsA##name(LLVMValueRef Val); 427LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST) 428 429/* Operations on constants of any type */ 430LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */ 431LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */ 432LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty); 433int LLVMIsConstant(LLVMValueRef Val); 434int LLVMIsNull(LLVMValueRef Val); 435int LLVMIsUndef(LLVMValueRef Val); 436LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty); 437 438/* Operations on scalar constants */ 439LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N, 440 int SignExtend); 441LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text, 442 uint8_t Radix); 443LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text, 444 unsigned SLen, uint8_t Radix); 445LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N); 446LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text); 447LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text, 448 unsigned SLen); 449 450 451/* Operations on composite constants */ 452LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str, 453 unsigned Length, int DontNullTerminate); 454LLVMValueRef LLVMConstStructInContext(LLVMContextRef C, 455 LLVMValueRef *ConstantVals, 456 unsigned Count, int Packed); 457 458LLVMValueRef LLVMConstString(const char *Str, unsigned Length, 459 int DontNullTerminate); 460LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy, 461 LLVMValueRef *ConstantVals, unsigned Length); 462LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count, 463 int Packed); 464LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size); 465 466/* Constant expressions */ 467LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty); 468LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty); 469LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal); 470LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal); 471LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal); 472LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 473LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 474LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 475LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 476LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 477LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 478LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 479LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 480LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 481LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 482LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 483LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 484LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 485LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 486LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 487LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, 488 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 489LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, 490 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 491LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 492LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 493LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 494LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, 495 LLVMValueRef *ConstantIndices, unsigned NumIndices); 496LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 497LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 498LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 499LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 500LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 501LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 502LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 503LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 504LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 505LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 506LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 507LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 508LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal, 509 LLVMTypeRef ToType); 510LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal, 511 LLVMTypeRef ToType); 512LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal, 513 LLVMTypeRef ToType); 514LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal, 515 LLVMTypeRef ToType); 516LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType, 517 unsigned isSigned); 518LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 519LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, 520 LLVMValueRef ConstantIfTrue, 521 LLVMValueRef ConstantIfFalse); 522LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, 523 LLVMValueRef IndexConstant); 524LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, 525 LLVMValueRef ElementValueConstant, 526 LLVMValueRef IndexConstant); 527LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, 528 LLVMValueRef VectorBConstant, 529 LLVMValueRef MaskConstant); 530LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList, 531 unsigned NumIdx); 532LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, 533 LLVMValueRef ElementValueConstant, 534 unsigned *IdxList, unsigned NumIdx); 535LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, 536 const char *AsmString, const char *Constraints, 537 int HasSideEffects); 538 539/* Operations on global variables, functions, and aliases (globals) */ 540LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global); 541int LLVMIsDeclaration(LLVMValueRef Global); 542LLVMLinkage LLVMGetLinkage(LLVMValueRef Global); 543void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage); 544const char *LLVMGetSection(LLVMValueRef Global); 545void LLVMSetSection(LLVMValueRef Global, const char *Section); 546LLVMVisibility LLVMGetVisibility(LLVMValueRef Global); 547void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz); 548unsigned LLVMGetAlignment(LLVMValueRef Global); 549void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes); 550 551/* Operations on global variables */ 552LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name); 553LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name); 554LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M); 555LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M); 556LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar); 557LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar); 558void LLVMDeleteGlobal(LLVMValueRef GlobalVar); 559LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar); 560void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal); 561int LLVMIsThreadLocal(LLVMValueRef GlobalVar); 562void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal); 563int LLVMIsGlobalConstant(LLVMValueRef GlobalVar); 564void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant); 565 566/* Operations on aliases */ 567LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee, 568 const char *Name); 569 570/* Operations on functions */ 571LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name, 572 LLVMTypeRef FunctionTy); 573LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name); 574LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M); 575LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M); 576LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn); 577LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn); 578void LLVMDeleteFunction(LLVMValueRef Fn); 579unsigned LLVMGetIntrinsicID(LLVMValueRef Fn); 580unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn); 581void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC); 582const char *LLVMGetGC(LLVMValueRef Fn); 583void LLVMSetGC(LLVMValueRef Fn, const char *Name); 584void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA); 585void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA); 586 587/* Operations on parameters */ 588unsigned LLVMCountParams(LLVMValueRef Fn); 589void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params); 590LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index); 591LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst); 592LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn); 593LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn); 594LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg); 595LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg); 596void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA); 597void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA); 598void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align); 599 600/* Operations on basic blocks */ 601LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB); 602int LLVMValueIsBasicBlock(LLVMValueRef Val); 603LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val); 604LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB); 605unsigned LLVMCountBasicBlocks(LLVMValueRef Fn); 606void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks); 607LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn); 608LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn); 609LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB); 610LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB); 611LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn); 612 613LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C, 614 LLVMValueRef Fn, 615 const char *Name); 616LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C, 617 LLVMBasicBlockRef BB, 618 const char *Name); 619 620LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name); 621LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB, 622 const char *Name); 623void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB); 624 625/* Operations on instructions */ 626LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst); 627LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB); 628LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB); 629LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst); 630LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst); 631 632/* Operations on call sites */ 633void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC); 634unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr); 635void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute); 636void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index, 637 LLVMAttribute); 638void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index, 639 unsigned align); 640 641/* Operations on call instructions (only) */ 642int LLVMIsTailCall(LLVMValueRef CallInst); 643void LLVMSetTailCall(LLVMValueRef CallInst, int IsTailCall); 644 645/* Operations on phi nodes */ 646void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues, 647 LLVMBasicBlockRef *IncomingBlocks, unsigned Count); 648unsigned LLVMCountIncoming(LLVMValueRef PhiNode); 649LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index); 650LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index); 651 652/*===-- Instruction builders ----------------------------------------------===*/ 653 654/* An instruction builder represents a point within a basic block, and is the 655 * exclusive means of building instructions using the C interface. 656 */ 657 658LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C); 659LLVMBuilderRef LLVMCreateBuilder(void); 660void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block, 661 LLVMValueRef Instr); 662void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr); 663void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block); 664LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder); 665void LLVMClearInsertionPosition(LLVMBuilderRef Builder); 666void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr); 667void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr, 668 const char *Name); 669void LLVMDisposeBuilder(LLVMBuilderRef Builder); 670 671/* Terminators */ 672LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef); 673LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V); 674LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals, 675 unsigned N); 676LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest); 677LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If, 678 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else); 679LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V, 680 LLVMBasicBlockRef Else, unsigned NumCases); 681LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn, 682 LLVMValueRef *Args, unsigned NumArgs, 683 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, 684 const char *Name); 685LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef); 686LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef); 687 688/* Add a case to the switch instruction */ 689void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal, 690 LLVMBasicBlockRef Dest); 691 692/* Arithmetic */ 693LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 694 const char *Name); 695LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 696 const char *Name); 697LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 698 const char *Name); 699LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 700 const char *Name); 701LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 702 const char *Name); 703LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 704 const char *Name); 705LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 706 const char *Name); 707LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 708 const char *Name); 709LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 710 const char *Name); 711LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 712 const char *Name); 713LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 714 const char *Name); 715LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 716 const char *Name); 717LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 718 const char *Name); 719LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 720 const char *Name); 721LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 722 const char *Name); 723LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 724 const char *Name); 725LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 726 const char *Name); 727LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 728 const char *Name); 729LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 730 const char *Name); 731LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 732 const char *Name); 733LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name); 734LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name); 735 736/* Memory */ 737LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 738LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty, 739 LLVMValueRef Val, const char *Name); 740LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 741LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty, 742 LLVMValueRef Val, const char *Name); 743LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal); 744LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal, 745 const char *Name); 746LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr); 747LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 748 LLVMValueRef *Indices, unsigned NumIndices, 749 const char *Name); 750LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 751 LLVMValueRef *Indices, unsigned NumIndices, 752 const char *Name); 753LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 754 unsigned Idx, const char *Name); 755LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str, 756 const char *Name); 757LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str, 758 const char *Name); 759 760/* Casts */ 761LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val, 762 LLVMTypeRef DestTy, const char *Name); 763LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val, 764 LLVMTypeRef DestTy, const char *Name); 765LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val, 766 LLVMTypeRef DestTy, const char *Name); 767LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val, 768 LLVMTypeRef DestTy, const char *Name); 769LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val, 770 LLVMTypeRef DestTy, const char *Name); 771LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val, 772 LLVMTypeRef DestTy, const char *Name); 773LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val, 774 LLVMTypeRef DestTy, const char *Name); 775LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val, 776 LLVMTypeRef DestTy, const char *Name); 777LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val, 778 LLVMTypeRef DestTy, const char *Name); 779LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val, 780 LLVMTypeRef DestTy, const char *Name); 781LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val, 782 LLVMTypeRef DestTy, const char *Name); 783LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val, 784 LLVMTypeRef DestTy, const char *Name); 785LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 786 LLVMTypeRef DestTy, const char *Name); 787LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 788 LLVMTypeRef DestTy, const char *Name); 789LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 790 LLVMTypeRef DestTy, const char *Name); 791LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val, 792 LLVMTypeRef DestTy, const char *Name); 793LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, 794 LLVMTypeRef DestTy, const char *Name); 795LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val, 796 LLVMTypeRef DestTy, const char *Name); 797 798/* Comparisons */ 799LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op, 800 LLVMValueRef LHS, LLVMValueRef RHS, 801 const char *Name); 802LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op, 803 LLVMValueRef LHS, LLVMValueRef RHS, 804 const char *Name); 805 806/* Miscellaneous instructions */ 807LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 808LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn, 809 LLVMValueRef *Args, unsigned NumArgs, 810 const char *Name); 811LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If, 812 LLVMValueRef Then, LLVMValueRef Else, 813 const char *Name); 814LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty, 815 const char *Name); 816LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal, 817 LLVMValueRef Index, const char *Name); 818LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal, 819 LLVMValueRef EltVal, LLVMValueRef Index, 820 const char *Name); 821LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1, 822 LLVMValueRef V2, LLVMValueRef Mask, 823 const char *Name); 824LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal, 825 unsigned Index, const char *Name); 826LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal, 827 LLVMValueRef EltVal, unsigned Index, 828 const char *Name); 829 830LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val, 831 const char *Name); 832LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val, 833 const char *Name); 834LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS, 835 LLVMValueRef RHS, const char *Name); 836 837 838/*===-- Module providers --------------------------------------------------===*/ 839 840/* Encapsulates the module M in a module provider, taking ownership of the 841 * module. 842 * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider. 843 */ 844LLVMModuleProviderRef 845LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M); 846 847/* Destroys the module provider MP as well as the contained module. 848 * See the destructor llvm::ModuleProvider::~ModuleProvider. 849 */ 850void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP); 851 852 853/*===-- Memory buffers ----------------------------------------------------===*/ 854 855int LLVMCreateMemoryBufferWithContentsOfFile(const char *Path, 856 LLVMMemoryBufferRef *OutMemBuf, 857 char **OutMessage); 858int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf, 859 char **OutMessage); 860void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf); 861 862 863/*===-- Pass Managers -----------------------------------------------------===*/ 864 865/** Constructs a new whole-module pass pipeline. This type of pipeline is 866 suitable for link-time optimization and whole-module transformations. 867 See llvm::PassManager::PassManager. */ 868LLVMPassManagerRef LLVMCreatePassManager(void); 869 870/** Constructs a new function-by-function pass pipeline over the module 871 provider. It does not take ownership of the module provider. This type of 872 pipeline is suitable for code generation and JIT compilation tasks. 873 See llvm::FunctionPassManager::FunctionPassManager. */ 874LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP); 875 876/** Initializes, executes on the provided module, and finalizes all of the 877 passes scheduled in the pass manager. Returns 1 if any of the passes 878 modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */ 879int LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M); 880 881/** Initializes all of the function passes scheduled in the function pass 882 manager. Returns 1 if any of the passes modified the module, 0 otherwise. 883 See llvm::FunctionPassManager::doInitialization. */ 884int LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM); 885 886/** Executes all of the function passes scheduled in the function pass manager 887 on the provided function. Returns 1 if any of the passes modified the 888 function, false otherwise. 889 See llvm::FunctionPassManager::run(Function&). */ 890int LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F); 891 892/** Finalizes all of the function passes scheduled in in the function pass 893 manager. Returns 1 if any of the passes modified the module, 0 otherwise. 894 See llvm::FunctionPassManager::doFinalization. */ 895int LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM); 896 897/** Frees the memory of a pass pipeline. For function pipelines, does not free 898 the module provider. 899 See llvm::PassManagerBase::~PassManagerBase. */ 900void LLVMDisposePassManager(LLVMPassManagerRef PM); 901 902 903#ifdef __cplusplus 904} 905 906namespace llvm { 907 class ModuleProvider; 908 class MemoryBuffer; 909 class PassManagerBase; 910 911 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \ 912 inline ty *unwrap(ref P) { \ 913 return reinterpret_cast<ty*>(P); \ 914 } \ 915 \ 916 inline ref wrap(const ty *P) { \ 917 return reinterpret_cast<ref>(const_cast<ty*>(P)); \ 918 } 919 920 #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref) \ 921 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \ 922 \ 923 template<typename T> \ 924 inline T *unwrap(ref P) { \ 925 return cast<T>(unwrap(P)); \ 926 } 927 928 #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref) \ 929 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \ 930 \ 931 template<typename T> \ 932 inline T *unwrap(ref P) { \ 933 T *Q = dynamic_cast<T*>(unwrap(P)); \ 934 assert(Q && "Invalid cast!"); \ 935 return Q; \ 936 } 937 938 DEFINE_ISA_CONVERSION_FUNCTIONS (Type, LLVMTypeRef ) 939 DEFINE_ISA_CONVERSION_FUNCTIONS (Value, LLVMValueRef ) 940 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef ) 941 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef ) 942 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef ) 943 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder, LLVMTypeHandleRef ) 944 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider, LLVMModuleProviderRef) 945 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef ) 946 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext, LLVMContextRef ) 947 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef ) 948 949 #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS 950 #undef DEFINE_ISA_CONVERSION_FUNCTIONS 951 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS 952 953 /* Specialized opaque context conversions. 954 */ 955 inline LLVMContext **unwrap(LLVMContextRef* Tys) { 956 return reinterpret_cast<LLVMContext**>(Tys); 957 } 958 959 inline LLVMContextRef *wrap(const LLVMContext **Tys) { 960 return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys)); 961 } 962 963 /* Specialized opaque type conversions. 964 */ 965 inline Type **unwrap(LLVMTypeRef* Tys) { 966 return reinterpret_cast<Type**>(Tys); 967 } 968 969 inline LLVMTypeRef *wrap(const Type **Tys) { 970 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys)); 971 } 972 973 /* Specialized opaque value conversions. 974 */ 975 inline Value **unwrap(LLVMValueRef *Vals) { 976 return reinterpret_cast<Value**>(Vals); 977 } 978 979 template<typename T> 980 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) { 981 #if DEBUG 982 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I) 983 cast<T>(*I); 984 #endif 985 return reinterpret_cast<T**>(Vals); 986 } 987 988 inline LLVMValueRef *wrap(const Value **Vals) { 989 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals)); 990 } 991} 992 993#endif /* !defined(__cplusplus) */ 994 995#endif /* !defined(LLVM_C_CORE_H) */ 996