Core.h revision 6e7ad958683f34bf6c014c88fef723e5a2d741be
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 LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 474LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 475LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 476LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 477LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 478LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 479LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 480LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 481LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 482LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 483LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 484LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 485LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 486LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 487LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 488LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 489LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, 490 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 491LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, 492 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 493LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 494LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 495LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 496LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, 497 LLVMValueRef *ConstantIndices, unsigned NumIndices); 498LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal, 499 LLVMValueRef *ConstantIndices, 500 unsigned NumIndices); 501LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 502LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 503LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 504LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 505LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 506LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 507LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 508LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 509LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 510LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 511LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 512LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 513LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal, 514 LLVMTypeRef ToType); 515LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal, 516 LLVMTypeRef ToType); 517LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal, 518 LLVMTypeRef ToType); 519LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal, 520 LLVMTypeRef ToType); 521LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType, 522 unsigned isSigned); 523LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 524LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, 525 LLVMValueRef ConstantIfTrue, 526 LLVMValueRef ConstantIfFalse); 527LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, 528 LLVMValueRef IndexConstant); 529LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, 530 LLVMValueRef ElementValueConstant, 531 LLVMValueRef IndexConstant); 532LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, 533 LLVMValueRef VectorBConstant, 534 LLVMValueRef MaskConstant); 535LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList, 536 unsigned NumIdx); 537LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, 538 LLVMValueRef ElementValueConstant, 539 unsigned *IdxList, unsigned NumIdx); 540LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, 541 const char *AsmString, const char *Constraints, 542 int HasSideEffects); 543 544/* Operations on global variables, functions, and aliases (globals) */ 545LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global); 546int LLVMIsDeclaration(LLVMValueRef Global); 547LLVMLinkage LLVMGetLinkage(LLVMValueRef Global); 548void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage); 549const char *LLVMGetSection(LLVMValueRef Global); 550void LLVMSetSection(LLVMValueRef Global, const char *Section); 551LLVMVisibility LLVMGetVisibility(LLVMValueRef Global); 552void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz); 553unsigned LLVMGetAlignment(LLVMValueRef Global); 554void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes); 555 556/* Operations on global variables */ 557LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name); 558LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name); 559LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M); 560LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M); 561LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar); 562LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar); 563void LLVMDeleteGlobal(LLVMValueRef GlobalVar); 564LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar); 565void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal); 566int LLVMIsThreadLocal(LLVMValueRef GlobalVar); 567void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal); 568int LLVMIsGlobalConstant(LLVMValueRef GlobalVar); 569void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant); 570 571/* Operations on aliases */ 572LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee, 573 const char *Name); 574 575/* Operations on functions */ 576LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name, 577 LLVMTypeRef FunctionTy); 578LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name); 579LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M); 580LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M); 581LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn); 582LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn); 583void LLVMDeleteFunction(LLVMValueRef Fn); 584unsigned LLVMGetIntrinsicID(LLVMValueRef Fn); 585unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn); 586void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC); 587const char *LLVMGetGC(LLVMValueRef Fn); 588void LLVMSetGC(LLVMValueRef Fn, const char *Name); 589void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA); 590void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA); 591 592/* Operations on parameters */ 593unsigned LLVMCountParams(LLVMValueRef Fn); 594void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params); 595LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index); 596LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst); 597LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn); 598LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn); 599LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg); 600LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg); 601void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA); 602void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA); 603void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align); 604 605/* Operations on basic blocks */ 606LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB); 607int LLVMValueIsBasicBlock(LLVMValueRef Val); 608LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val); 609LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB); 610unsigned LLVMCountBasicBlocks(LLVMValueRef Fn); 611void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks); 612LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn); 613LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn); 614LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB); 615LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB); 616LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn); 617 618LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C, 619 LLVMValueRef Fn, 620 const char *Name); 621LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C, 622 LLVMBasicBlockRef BB, 623 const char *Name); 624 625LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name); 626LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB, 627 const char *Name); 628void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB); 629 630/* Operations on instructions */ 631LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst); 632LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB); 633LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB); 634LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst); 635LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst); 636 637/* Operations on call sites */ 638void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC); 639unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr); 640void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute); 641void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index, 642 LLVMAttribute); 643void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index, 644 unsigned align); 645 646/* Operations on call instructions (only) */ 647int LLVMIsTailCall(LLVMValueRef CallInst); 648void LLVMSetTailCall(LLVMValueRef CallInst, int IsTailCall); 649 650/* Operations on phi nodes */ 651void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues, 652 LLVMBasicBlockRef *IncomingBlocks, unsigned Count); 653unsigned LLVMCountIncoming(LLVMValueRef PhiNode); 654LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index); 655LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index); 656 657/*===-- Instruction builders ----------------------------------------------===*/ 658 659/* An instruction builder represents a point within a basic block, and is the 660 * exclusive means of building instructions using the C interface. 661 */ 662 663LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C); 664LLVMBuilderRef LLVMCreateBuilder(void); 665void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block, 666 LLVMValueRef Instr); 667void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr); 668void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block); 669LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder); 670void LLVMClearInsertionPosition(LLVMBuilderRef Builder); 671void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr); 672void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr, 673 const char *Name); 674void LLVMDisposeBuilder(LLVMBuilderRef Builder); 675 676/* Terminators */ 677LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef); 678LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V); 679LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals, 680 unsigned N); 681LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest); 682LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If, 683 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else); 684LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V, 685 LLVMBasicBlockRef Else, unsigned NumCases); 686LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn, 687 LLVMValueRef *Args, unsigned NumArgs, 688 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, 689 const char *Name); 690LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef); 691LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef); 692 693/* Add a case to the switch instruction */ 694void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal, 695 LLVMBasicBlockRef Dest); 696 697/* Arithmetic */ 698LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 699 const char *Name); 700LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 701 const char *Name); 702LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 703 const char *Name); 704LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 705 const char *Name); 706LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 707 const char *Name); 708LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 709 const char *Name); 710LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 711 const char *Name); 712LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 713 const char *Name); 714LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 715 const char *Name); 716LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 717 const char *Name); 718LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 719 const char *Name); 720LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 721 const char *Name); 722LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 723 const char *Name); 724LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 725 const char *Name); 726LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 727 const char *Name); 728LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 729 const char *Name); 730LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 731 const char *Name); 732LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 733 const char *Name); 734LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 735 const char *Name); 736LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 737 const char *Name); 738LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name); 739LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name); 740 741/* Memory */ 742LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 743LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty, 744 LLVMValueRef Val, const char *Name); 745LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 746LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty, 747 LLVMValueRef Val, const char *Name); 748LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal); 749LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal, 750 const char *Name); 751LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr); 752LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 753 LLVMValueRef *Indices, unsigned NumIndices, 754 const char *Name); 755LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 756 LLVMValueRef *Indices, unsigned NumIndices, 757 const char *Name); 758LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 759 unsigned Idx, const char *Name); 760LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str, 761 const char *Name); 762LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str, 763 const char *Name); 764 765/* Casts */ 766LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val, 767 LLVMTypeRef DestTy, const char *Name); 768LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val, 769 LLVMTypeRef DestTy, const char *Name); 770LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val, 771 LLVMTypeRef DestTy, const char *Name); 772LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val, 773 LLVMTypeRef DestTy, const char *Name); 774LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val, 775 LLVMTypeRef DestTy, const char *Name); 776LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val, 777 LLVMTypeRef DestTy, const char *Name); 778LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val, 779 LLVMTypeRef DestTy, const char *Name); 780LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val, 781 LLVMTypeRef DestTy, const char *Name); 782LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val, 783 LLVMTypeRef DestTy, const char *Name); 784LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val, 785 LLVMTypeRef DestTy, const char *Name); 786LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val, 787 LLVMTypeRef DestTy, const char *Name); 788LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val, 789 LLVMTypeRef DestTy, const char *Name); 790LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 791 LLVMTypeRef DestTy, const char *Name); 792LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 793 LLVMTypeRef DestTy, const char *Name); 794LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 795 LLVMTypeRef DestTy, const char *Name); 796LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val, 797 LLVMTypeRef DestTy, const char *Name); 798LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, 799 LLVMTypeRef DestTy, const char *Name); 800LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val, 801 LLVMTypeRef DestTy, const char *Name); 802 803/* Comparisons */ 804LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op, 805 LLVMValueRef LHS, LLVMValueRef RHS, 806 const char *Name); 807LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op, 808 LLVMValueRef LHS, LLVMValueRef RHS, 809 const char *Name); 810 811/* Miscellaneous instructions */ 812LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 813LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn, 814 LLVMValueRef *Args, unsigned NumArgs, 815 const char *Name); 816LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If, 817 LLVMValueRef Then, LLVMValueRef Else, 818 const char *Name); 819LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty, 820 const char *Name); 821LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal, 822 LLVMValueRef Index, const char *Name); 823LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal, 824 LLVMValueRef EltVal, LLVMValueRef Index, 825 const char *Name); 826LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1, 827 LLVMValueRef V2, LLVMValueRef Mask, 828 const char *Name); 829LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal, 830 unsigned Index, const char *Name); 831LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal, 832 LLVMValueRef EltVal, unsigned Index, 833 const char *Name); 834 835LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val, 836 const char *Name); 837LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val, 838 const char *Name); 839LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS, 840 LLVMValueRef RHS, const char *Name); 841 842 843/*===-- Module providers --------------------------------------------------===*/ 844 845/* Encapsulates the module M in a module provider, taking ownership of the 846 * module. 847 * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider. 848 */ 849LLVMModuleProviderRef 850LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M); 851 852/* Destroys the module provider MP as well as the contained module. 853 * See the destructor llvm::ModuleProvider::~ModuleProvider. 854 */ 855void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP); 856 857 858/*===-- Memory buffers ----------------------------------------------------===*/ 859 860int LLVMCreateMemoryBufferWithContentsOfFile(const char *Path, 861 LLVMMemoryBufferRef *OutMemBuf, 862 char **OutMessage); 863int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf, 864 char **OutMessage); 865void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf); 866 867 868/*===-- Pass Managers -----------------------------------------------------===*/ 869 870/** Constructs a new whole-module pass pipeline. This type of pipeline is 871 suitable for link-time optimization and whole-module transformations. 872 See llvm::PassManager::PassManager. */ 873LLVMPassManagerRef LLVMCreatePassManager(void); 874 875/** Constructs a new function-by-function pass pipeline over the module 876 provider. It does not take ownership of the module provider. This type of 877 pipeline is suitable for code generation and JIT compilation tasks. 878 See llvm::FunctionPassManager::FunctionPassManager. */ 879LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP); 880 881/** Initializes, executes on the provided module, and finalizes all of the 882 passes scheduled in the pass manager. Returns 1 if any of the passes 883 modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */ 884int LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M); 885 886/** Initializes all of the function passes scheduled in the function pass 887 manager. Returns 1 if any of the passes modified the module, 0 otherwise. 888 See llvm::FunctionPassManager::doInitialization. */ 889int LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM); 890 891/** Executes all of the function passes scheduled in the function pass manager 892 on the provided function. Returns 1 if any of the passes modified the 893 function, false otherwise. 894 See llvm::FunctionPassManager::run(Function&). */ 895int LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F); 896 897/** Finalizes all of the function passes scheduled in in the function pass 898 manager. Returns 1 if any of the passes modified the module, 0 otherwise. 899 See llvm::FunctionPassManager::doFinalization. */ 900int LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM); 901 902/** Frees the memory of a pass pipeline. For function pipelines, does not free 903 the module provider. 904 See llvm::PassManagerBase::~PassManagerBase. */ 905void LLVMDisposePassManager(LLVMPassManagerRef PM); 906 907 908#ifdef __cplusplus 909} 910 911namespace llvm { 912 class ModuleProvider; 913 class MemoryBuffer; 914 class PassManagerBase; 915 916 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \ 917 inline ty *unwrap(ref P) { \ 918 return reinterpret_cast<ty*>(P); \ 919 } \ 920 \ 921 inline ref wrap(const ty *P) { \ 922 return reinterpret_cast<ref>(const_cast<ty*>(P)); \ 923 } 924 925 #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref) \ 926 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \ 927 \ 928 template<typename T> \ 929 inline T *unwrap(ref P) { \ 930 return cast<T>(unwrap(P)); \ 931 } 932 933 #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref) \ 934 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \ 935 \ 936 template<typename T> \ 937 inline T *unwrap(ref P) { \ 938 T *Q = dynamic_cast<T*>(unwrap(P)); \ 939 assert(Q && "Invalid cast!"); \ 940 return Q; \ 941 } 942 943 DEFINE_ISA_CONVERSION_FUNCTIONS (Type, LLVMTypeRef ) 944 DEFINE_ISA_CONVERSION_FUNCTIONS (Value, LLVMValueRef ) 945 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef ) 946 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef ) 947 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef ) 948 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder, LLVMTypeHandleRef ) 949 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider, LLVMModuleProviderRef) 950 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef ) 951 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext, LLVMContextRef ) 952 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef ) 953 954 #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS 955 #undef DEFINE_ISA_CONVERSION_FUNCTIONS 956 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS 957 958 /* Specialized opaque context conversions. 959 */ 960 inline LLVMContext **unwrap(LLVMContextRef* Tys) { 961 return reinterpret_cast<LLVMContext**>(Tys); 962 } 963 964 inline LLVMContextRef *wrap(const LLVMContext **Tys) { 965 return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys)); 966 } 967 968 /* Specialized opaque type conversions. 969 */ 970 inline Type **unwrap(LLVMTypeRef* Tys) { 971 return reinterpret_cast<Type**>(Tys); 972 } 973 974 inline LLVMTypeRef *wrap(const Type **Tys) { 975 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys)); 976 } 977 978 /* Specialized opaque value conversions. 979 */ 980 inline Value **unwrap(LLVMValueRef *Vals) { 981 return reinterpret_cast<Value**>(Vals); 982 } 983 984 template<typename T> 985 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) { 986 #if DEBUG 987 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I) 988 cast<T>(*I); 989 #endif 990 return reinterpret_cast<T**>(Vals); 991 } 992 993 inline LLVMValueRef *wrap(const Value **Vals) { 994 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals)); 995 } 996} 997 998#endif /* !defined(__cplusplus) */ 999 1000#endif /* !defined(LLVM_C_CORE_H) */ 1001