LLVM API Documentation
00001 /*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\ 00002 |* *| 00003 |* The LLVM Compiler Infrastructure *| 00004 |* *| 00005 |* This file is distributed under the University of Illinois Open Source *| 00006 |* License. See LICENSE.TXT for details. *| 00007 |* *| 00008 |*===----------------------------------------------------------------------===*| 00009 |* *| 00010 |* This header declares the C interface to libLLVMCore.a, which implements *| 00011 |* the LLVM intermediate representation. *| 00012 |* *| 00013 |* LLVM uses a polymorphic type hierarchy which C cannot represent, therefore *| 00014 |* parameters must be passed as base types. Despite the declared types, most *| 00015 |* of the functions provided operate only on branches of the type hierarchy. *| 00016 |* The declared parameter names are descriptive and specify which type is *| 00017 |* required. Additionally, each type hierarchy is documented along with the *| 00018 |* functions that operate upon it. For more detail, refer to LLVM's C++ code. *| 00019 |* If in doubt, refer to Core.cpp, which performs paramter downcasts in the *| 00020 |* form unwrap<RequiredType>(Param). *| 00021 |* *| 00022 |* Many exotic languages can interoperate with C code but have a harder time *| 00023 |* with C++ due to name mangling. So in addition to C, this interface enables *| 00024 |* tools written in such languages. *| 00025 |* *| 00026 |* When included into a C++ source file, also declares 'wrap' and 'unwrap' *| 00027 |* helpers to perform opaque reference<-->pointer conversions. These helpers *| 00028 |* are shorter and more tightly typed than writing the casts by hand when *| 00029 |* authoring bindings. In assert builds, they will do runtime type checking. *| 00030 |* *| 00031 \*===----------------------------------------------------------------------===*/ 00032 00033 #ifndef LLVM_C_CORE_H 00034 #define LLVM_C_CORE_H 00035 00036 #include "llvm/Support/DataTypes.h" 00037 00038 #ifdef __cplusplus 00039 00040 /* Need these includes to support the LLVM 'cast' template for the C++ 'wrap' 00041 and 'unwrap' conversion functions. */ 00042 #include "llvm/Module.h" 00043 #include "llvm/Support/IRBuilder.h" 00044 00045 extern "C" { 00046 #endif 00047 00048 00049 /* Opaque types. */ 00050 00051 /** 00052 * The top-level container for all LLVM global data. See the LLVMContext class. 00053 */ 00054 typedef struct LLVMOpaqueContext *LLVMContextRef; 00055 00056 /** 00057 * The top-level container for all other LLVM Intermediate Representation (IR) 00058 * objects. See the llvm::Module class. 00059 */ 00060 typedef struct LLVMOpaqueModule *LLVMModuleRef; 00061 00062 /** 00063 * Each value in the LLVM IR has a type, an LLVMTypeRef. See the llvm::Type 00064 * class. 00065 */ 00066 typedef struct LLVMOpaqueType *LLVMTypeRef; 00067 00068 /** 00069 * When building recursive types using LLVMRefineType, LLVMTypeRef values may 00070 * become invalid; use LLVMTypeHandleRef to resolve this problem. See the 00071 * llvm::AbstractTypeHolder class. 00072 */ 00073 typedef struct LLVMOpaqueTypeHandle *LLVMTypeHandleRef; 00074 00075 typedef struct LLVMOpaqueValue *LLVMValueRef; 00076 typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef; 00077 typedef struct LLVMOpaqueBuilder *LLVMBuilderRef; 00078 00079 /* Used to provide a module to JIT or interpreter. 00080 * See the llvm::ModuleProvider class. 00081 */ 00082 typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef; 00083 00084 /* Used to provide a module to JIT or interpreter. 00085 * See the llvm::MemoryBuffer class. 00086 */ 00087 typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef; 00088 00089 /** See the llvm::PassManagerBase class. */ 00090 typedef struct LLVMOpaquePassManager *LLVMPassManagerRef; 00091 00092 typedef enum { 00093 LLVMZExtAttribute = 1<<0, 00094 LLVMSExtAttribute = 1<<1, 00095 LLVMNoReturnAttribute = 1<<2, 00096 LLVMInRegAttribute = 1<<3, 00097 LLVMStructRetAttribute = 1<<4, 00098 LLVMNoUnwindAttribute = 1<<5, 00099 LLVMNoAliasAttribute = 1<<6, 00100 LLVMByValAttribute = 1<<7, 00101 LLVMNestAttribute = 1<<8, 00102 LLVMReadNoneAttribute = 1<<9, 00103 LLVMReadOnlyAttribute = 1<<10, 00104 LLVMNoInlineAttribute = 1<<11, 00105 LLVMAlwaysInlineAttribute = 1<<12, 00106 LLVMOptimizeForSizeAttribute = 1<<13, 00107 LLVMStackProtectAttribute = 1<<14, 00108 LLVMStackProtectReqAttribute = 1<<15, 00109 LLVMNoCaptureAttribute = 1<<21, 00110 LLVMNoRedZoneAttribute = 1<<22, 00111 LLVMNoImplicitFloatAttribute = 1<<23, 00112 LLVMNakedAttribute = 1<<24 00113 } LLVMAttribute; 00114 00115 typedef enum { 00116 LLVMVoidTypeKind, /**< type with no size */ 00117 LLVMFloatTypeKind, /**< 32 bit floating point type */ 00118 LLVMDoubleTypeKind, /**< 64 bit floating point type */ 00119 LLVMX86_FP80TypeKind, /**< 80 bit floating point type (X87) */ 00120 LLVMFP128TypeKind, /**< 128 bit floating point type (112-bit mantissa)*/ 00121 LLVMPPC_FP128TypeKind, /**< 128 bit floating point type (two 64-bits) */ 00122 LLVMLabelTypeKind, /**< Labels */ 00123 LLVMIntegerTypeKind, /**< Arbitrary bit width integers */ 00124 LLVMFunctionTypeKind, /**< Functions */ 00125 LLVMStructTypeKind, /**< Structures */ 00126 LLVMArrayTypeKind, /**< Arrays */ 00127 LLVMPointerTypeKind, /**< Pointers */ 00128 LLVMOpaqueTypeKind, /**< Opaque: type with unknown structure */ 00129 LLVMVectorTypeKind, /**< SIMD 'packed' format, or other vector type */ 00130 LLVMMetadataTypeKind /**< Metadata */ 00131 } LLVMTypeKind; 00132 00133 typedef enum { 00134 LLVMExternalLinkage, /**< Externally visible function */ 00135 LLVMAvailableExternallyLinkage, 00136 LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/ 00137 LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something 00138 equivalent. */ 00139 LLVMWeakAnyLinkage, /**< Keep one copy of function when linking (weak) */ 00140 LLVMWeakODRLinkage, /**< Same, but only replaced by something 00141 equivalent. */ 00142 LLVMAppendingLinkage, /**< Special purpose, only applies to global arrays */ 00143 LLVMInternalLinkage, /**< Rename collisions when linking (static 00144 functions) */ 00145 LLVMPrivateLinkage, /**< Like Internal, but omit from symbol table */ 00146 LLVMDLLImportLinkage, /**< Function to be imported from DLL */ 00147 LLVMDLLExportLinkage, /**< Function to be accessible from DLL */ 00148 LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */ 00149 LLVMGhostLinkage, /**< Stand-in functions for streaming fns from 00150 bitcode */ 00151 LLVMCommonLinkage, /**< Tentative definitions */ 00152 LLVMLinkerPrivateLinkage /**< Like Private, but linker removes. */ 00153 } LLVMLinkage; 00154 00155 typedef enum { 00156 LLVMDefaultVisibility, /**< The GV is visible */ 00157 LLVMHiddenVisibility, /**< The GV is hidden */ 00158 LLVMProtectedVisibility /**< The GV is protected */ 00159 } LLVMVisibility; 00160 00161 typedef enum { 00162 LLVMCCallConv = 0, 00163 LLVMFastCallConv = 8, 00164 LLVMColdCallConv = 9, 00165 LLVMX86StdcallCallConv = 64, 00166 LLVMX86FastcallCallConv = 65 00167 } LLVMCallConv; 00168 00169 typedef enum { 00170 LLVMIntEQ = 32, /**< equal */ 00171 LLVMIntNE, /**< not equal */ 00172 LLVMIntUGT, /**< unsigned greater than */ 00173 LLVMIntUGE, /**< unsigned greater or equal */ 00174 LLVMIntULT, /**< unsigned less than */ 00175 LLVMIntULE, /**< unsigned less or equal */ 00176 LLVMIntSGT, /**< signed greater than */ 00177 LLVMIntSGE, /**< signed greater or equal */ 00178 LLVMIntSLT, /**< signed less than */ 00179 LLVMIntSLE /**< signed less or equal */ 00180 } LLVMIntPredicate; 00181 00182 typedef enum { 00183 LLVMRealPredicateFalse, /**< Always false (always folded) */ 00184 LLVMRealOEQ, /**< True if ordered and equal */ 00185 LLVMRealOGT, /**< True if ordered and greater than */ 00186 LLVMRealOGE, /**< True if ordered and greater than or equal */ 00187 LLVMRealOLT, /**< True if ordered and less than */ 00188 LLVMRealOLE, /**< True if ordered and less than or equal */ 00189 LLVMRealONE, /**< True if ordered and operands are unequal */ 00190 LLVMRealORD, /**< True if ordered (no nans) */ 00191 LLVMRealUNO, /**< True if unordered: isnan(X) | isnan(Y) */ 00192 LLVMRealUEQ, /**< True if unordered or equal */ 00193 LLVMRealUGT, /**< True if unordered or greater than */ 00194 LLVMRealUGE, /**< True if unordered, greater than, or equal */ 00195 LLVMRealULT, /**< True if unordered or less than */ 00196 LLVMRealULE, /**< True if unordered, less than, or equal */ 00197 LLVMRealUNE, /**< True if unordered or not equal */ 00198 LLVMRealPredicateTrue /**< Always true (always folded) */ 00199 } LLVMRealPredicate; 00200 00201 00202 /*===-- Error handling ----------------------------------------------------===*/ 00203 00204 void LLVMDisposeMessage(char *Message); 00205 00206 00207 /*===-- Modules -----------------------------------------------------------===*/ 00208 00209 /* Create and destroy contexts. */ 00210 LLVMContextRef LLVMContextCreate(void); 00211 LLVMContextRef LLVMGetGlobalContext(void); 00212 void LLVMContextDispose(LLVMContextRef C); 00213 00214 /* Create and destroy modules. */ 00215 /** See llvm::Module::Module. */ 00216 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID); 00217 LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID, 00218 LLVMContextRef C); 00219 00220 /** See llvm::Module::~Module. */ 00221 void LLVMDisposeModule(LLVMModuleRef M); 00222 00223 /** Data layout. See Module::getDataLayout. */ 00224 const char *LLVMGetDataLayout(LLVMModuleRef M); 00225 void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple); 00226 00227 /** Target triple. See Module::getTargetTriple. */ 00228 const char *LLVMGetTarget(LLVMModuleRef M); 00229 void LLVMSetTarget(LLVMModuleRef M, const char *Triple); 00230 00231 /** See Module::addTypeName. */ 00232 int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty); 00233 void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name); 00234 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name); 00235 00236 /** See Module::dump. */ 00237 void LLVMDumpModule(LLVMModuleRef M); 00238 00239 00240 /*===-- Types -------------------------------------------------------------===*/ 00241 00242 /* LLVM types conform to the following hierarchy: 00243 * 00244 * types: 00245 * integer type 00246 * real type 00247 * function type 00248 * sequence types: 00249 * array type 00250 * pointer type 00251 * vector type 00252 * void type 00253 * label type 00254 * opaque type 00255 */ 00256 00257 /** See llvm::LLVMTypeKind::getTypeID. */ 00258 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty); 00259 00260 /** See llvm::LLVMType::getContext. */ 00261 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty); 00262 00263 /* Operations on integer types */ 00264 LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C); 00265 LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C); 00266 LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C); 00267 LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C); 00268 LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C); 00269 LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits); 00270 00271 LLVMTypeRef LLVMInt1Type(void); 00272 LLVMTypeRef LLVMInt8Type(void); 00273 LLVMTypeRef LLVMInt16Type(void); 00274 LLVMTypeRef LLVMInt32Type(void); 00275 LLVMTypeRef LLVMInt64Type(void); 00276 LLVMTypeRef LLVMIntType(unsigned NumBits); 00277 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy); 00278 00279 /* Operations on real types */ 00280 LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C); 00281 LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C); 00282 LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C); 00283 LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C); 00284 LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C); 00285 00286 LLVMTypeRef LLVMFloatType(void); 00287 LLVMTypeRef LLVMDoubleType(void); 00288 LLVMTypeRef LLVMX86FP80Type(void); 00289 LLVMTypeRef LLVMFP128Type(void); 00290 LLVMTypeRef LLVMPPCFP128Type(void); 00291 00292 /* Operations on function types */ 00293 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType, 00294 LLVMTypeRef *ParamTypes, unsigned ParamCount, 00295 int IsVarArg); 00296 int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy); 00297 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy); 00298 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy); 00299 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest); 00300 00301 /* Operations on struct types */ 00302 LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes, 00303 unsigned ElementCount, int Packed); 00304 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount, 00305 int Packed); 00306 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy); 00307 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest); 00308 int LLVMIsPackedStruct(LLVMTypeRef StructTy); 00309 00310 /* Operations on array, pointer, and vector types (sequence types) */ 00311 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount); 00312 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace); 00313 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount); 00314 00315 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty); 00316 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy); 00317 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy); 00318 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy); 00319 00320 /* Operations on other types */ 00321 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C); 00322 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C); 00323 LLVMTypeRef LLVMOpaqueTypeInContext(LLVMContextRef C); 00324 00325 LLVMTypeRef LLVMVoidType(void); 00326 LLVMTypeRef LLVMLabelType(void); 00327 LLVMTypeRef LLVMOpaqueType(void); 00328 00329 /* Operations on type handles */ 00330 LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy); 00331 void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy); 00332 LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle); 00333 void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle); 00334 00335 00336 /*===-- Values ------------------------------------------------------------===*/ 00337 00338 /* The bulk of LLVM's object model consists of values, which comprise a very 00339 * rich type hierarchy. 00340 */ 00341 00342 #define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \ 00343 macro(Argument) \ 00344 macro(BasicBlock) \ 00345 macro(InlineAsm) \ 00346 macro(User) \ 00347 macro(Constant) \ 00348 macro(ConstantAggregateZero) \ 00349 macro(ConstantArray) \ 00350 macro(ConstantExpr) \ 00351 macro(ConstantFP) \ 00352 macro(ConstantInt) \ 00353 macro(ConstantPointerNull) \ 00354 macro(ConstantStruct) \ 00355 macro(ConstantVector) \ 00356 macro(GlobalValue) \ 00357 macro(Function) \ 00358 macro(GlobalAlias) \ 00359 macro(GlobalVariable) \ 00360 macro(UndefValue) \ 00361 macro(Instruction) \ 00362 macro(BinaryOperator) \ 00363 macro(CallInst) \ 00364 macro(IntrinsicInst) \ 00365 macro(DbgInfoIntrinsic) \ 00366 macro(DbgDeclareInst) \ 00367 macro(DbgFuncStartInst) \ 00368 macro(DbgRegionEndInst) \ 00369 macro(DbgRegionStartInst) \ 00370 macro(DbgStopPointInst) \ 00371 macro(EHSelectorInst) \ 00372 macro(MemIntrinsic) \ 00373 macro(MemCpyInst) \ 00374 macro(MemMoveInst) \ 00375 macro(MemSetInst) \ 00376 macro(CmpInst) \ 00377 macro(FCmpInst) \ 00378 macro(ICmpInst) \ 00379 macro(ExtractElementInst) \ 00380 macro(GetElementPtrInst) \ 00381 macro(InsertElementInst) \ 00382 macro(InsertValueInst) \ 00383 macro(PHINode) \ 00384 macro(SelectInst) \ 00385 macro(ShuffleVectorInst) \ 00386 macro(StoreInst) \ 00387 macro(TerminatorInst) \ 00388 macro(BranchInst) \ 00389 macro(InvokeInst) \ 00390 macro(ReturnInst) \ 00391 macro(SwitchInst) \ 00392 macro(UnreachableInst) \ 00393 macro(UnwindInst) \ 00394 macro(UnaryInstruction) \ 00395 macro(AllocationInst) \ 00396 macro(AllocaInst) \ 00397 macro(MallocInst) \ 00398 macro(CastInst) \ 00399 macro(BitCastInst) \ 00400 macro(FPExtInst) \ 00401 macro(FPToSIInst) \ 00402 macro(FPToUIInst) \ 00403 macro(FPTruncInst) \ 00404 macro(IntToPtrInst) \ 00405 macro(PtrToIntInst) \ 00406 macro(SExtInst) \ 00407 macro(SIToFPInst) \ 00408 macro(TruncInst) \ 00409 macro(UIToFPInst) \ 00410 macro(ZExtInst) \ 00411 macro(ExtractValueInst) \ 00412 macro(FreeInst) \ 00413 macro(LoadInst) \ 00414 macro(VAArgInst) 00415 00416 /* Operations on all values */ 00417 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val); 00418 const char *LLVMGetValueName(LLVMValueRef Val); 00419 void LLVMSetValueName(LLVMValueRef Val, const char *Name); 00420 void LLVMDumpValue(LLVMValueRef Val); 00421 00422 /* Conversion functions. Return the input value if it is an instance of the 00423 specified class, otherwise NULL. See llvm::dyn_cast_or_null<>. */ 00424 #define LLVM_DECLARE_VALUE_CAST(name) \ 00425 LLVMValueRef LLVMIsA##name(LLVMValueRef Val); 00426 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST) 00427 00428 /* Operations on constants of any type */ 00429 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */ 00430 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */ 00431 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty); 00432 int LLVMIsConstant(LLVMValueRef Val); 00433 int LLVMIsNull(LLVMValueRef Val); 00434 int LLVMIsUndef(LLVMValueRef Val); 00435 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty); 00436 00437 /* Operations on scalar constants */ 00438 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N, 00439 int SignExtend); 00440 LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text, 00441 uint8_t Radix); 00442 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text, 00443 unsigned SLen, uint8_t Radix); 00444 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N); 00445 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text); 00446 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text, 00447 unsigned SLen); 00448 00449 00450 /* Operations on composite constants */ 00451 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str, 00452 unsigned Length, int DontNullTerminate); 00453 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C, 00454 LLVMValueRef *ConstantVals, 00455 unsigned Count, int Packed); 00456 00457 LLVMValueRef LLVMConstString(const char *Str, unsigned Length, 00458 int DontNullTerminate); 00459 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy, 00460 LLVMValueRef *ConstantVals, unsigned Length); 00461 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count, 00462 int Packed); 00463 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size); 00464 00465 /* Constant expressions */ 00466 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty); 00467 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty); 00468 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal); 00469 LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal); 00470 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal); 00471 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00472 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00473 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00474 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00475 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00476 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00477 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00478 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00479 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00480 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00481 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00482 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00483 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00484 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00485 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00486 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00487 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00488 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, 00489 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00490 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, 00491 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00492 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00493 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00494 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); 00495 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, 00496 LLVMValueRef *ConstantIndices, unsigned NumIndices); 00497 LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal, 00498 LLVMValueRef *ConstantIndices, 00499 unsigned NumIndices); 00500 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 00501 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 00502 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 00503 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 00504 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 00505 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 00506 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 00507 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 00508 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 00509 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 00510 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 00511 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 00512 LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal, 00513 LLVMTypeRef ToType); 00514 LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal, 00515 LLVMTypeRef ToType); 00516 LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal, 00517 LLVMTypeRef ToType); 00518 LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal, 00519 LLVMTypeRef ToType); 00520 LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType, 00521 unsigned isSigned); 00522 LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); 00523 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, 00524 LLVMValueRef ConstantIfTrue, 00525 LLVMValueRef ConstantIfFalse); 00526 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, 00527 LLVMValueRef IndexConstant); 00528 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, 00529 LLVMValueRef ElementValueConstant, 00530 LLVMValueRef IndexConstant); 00531 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, 00532 LLVMValueRef VectorBConstant, 00533 LLVMValueRef MaskConstant); 00534 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList, 00535 unsigned NumIdx); 00536 LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, 00537 LLVMValueRef ElementValueConstant, 00538 unsigned *IdxList, unsigned NumIdx); 00539 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, 00540 const char *AsmString, const char *Constraints, 00541 int HasSideEffects); 00542 00543 /* Operations on global variables, functions, and aliases (globals) */ 00544 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global); 00545 int LLVMIsDeclaration(LLVMValueRef Global); 00546 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global); 00547 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage); 00548 const char *LLVMGetSection(LLVMValueRef Global); 00549 void LLVMSetSection(LLVMValueRef Global, const char *Section); 00550 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global); 00551 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz); 00552 unsigned LLVMGetAlignment(LLVMValueRef Global); 00553 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes); 00554 00555 /* Operations on global variables */ 00556 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name); 00557 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name); 00558 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M); 00559 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M); 00560 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar); 00561 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar); 00562 void LLVMDeleteGlobal(LLVMValueRef GlobalVar); 00563 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar); 00564 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal); 00565 int LLVMIsThreadLocal(LLVMValueRef GlobalVar); 00566 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal); 00567 int LLVMIsGlobalConstant(LLVMValueRef GlobalVar); 00568 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant); 00569 00570 /* Operations on aliases */ 00571 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee, 00572 const char *Name); 00573 00574 /* Operations on functions */ 00575 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name, 00576 LLVMTypeRef FunctionTy); 00577 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name); 00578 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M); 00579 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M); 00580 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn); 00581 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn); 00582 void LLVMDeleteFunction(LLVMValueRef Fn); 00583 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn); 00584 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn); 00585 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC); 00586 const char *LLVMGetGC(LLVMValueRef Fn); 00587 void LLVMSetGC(LLVMValueRef Fn, const char *Name); 00588 void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA); 00589 void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA); 00590 00591 /* Operations on parameters */ 00592 unsigned LLVMCountParams(LLVMValueRef Fn); 00593 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params); 00594 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index); 00595 LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst); 00596 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn); 00597 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn); 00598 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg); 00599 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg); 00600 void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA); 00601 void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA); 00602 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align); 00603 00604 /* Operations on basic blocks */ 00605 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB); 00606 int LLVMValueIsBasicBlock(LLVMValueRef Val); 00607 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val); 00608 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB); 00609 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn); 00610 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks); 00611 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn); 00612 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn); 00613 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB); 00614 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB); 00615 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn); 00616 00617 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C, 00618 LLVMValueRef Fn, 00619 const char *Name); 00620 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C, 00621 LLVMBasicBlockRef BB, 00622 const char *Name); 00623 00624 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name); 00625 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB, 00626 const char *Name); 00627 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB); 00628 00629 /* Operations on instructions */ 00630 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst); 00631 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB); 00632 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB); 00633 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst); 00634 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst); 00635 00636 /* Operations on call sites */ 00637 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC); 00638 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr); 00639 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute); 00640 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index, 00641 LLVMAttribute); 00642 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index, 00643 unsigned align); 00644 00645 /* Operations on call instructions (only) */ 00646 int LLVMIsTailCall(LLVMValueRef CallInst); 00647 void LLVMSetTailCall(LLVMValueRef CallInst, int IsTailCall); 00648 00649 /* Operations on phi nodes */ 00650 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues, 00651 LLVMBasicBlockRef *IncomingBlocks, unsigned Count); 00652 unsigned LLVMCountIncoming(LLVMValueRef PhiNode); 00653 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index); 00654 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index); 00655 00656 /*===-- Instruction builders ----------------------------------------------===*/ 00657 00658 /* An instruction builder represents a point within a basic block, and is the 00659 * exclusive means of building instructions using the C interface. 00660 */ 00661 00662 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C); 00663 LLVMBuilderRef LLVMCreateBuilder(void); 00664 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block, 00665 LLVMValueRef Instr); 00666 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr); 00667 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block); 00668 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder); 00669 void LLVMClearInsertionPosition(LLVMBuilderRef Builder); 00670 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr); 00671 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr, 00672 const char *Name); 00673 void LLVMDisposeBuilder(LLVMBuilderRef Builder); 00674 00675 /* Terminators */ 00676 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef); 00677 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V); 00678 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals, 00679 unsigned N); 00680 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest); 00681 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If, 00682 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else); 00683 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V, 00684 LLVMBasicBlockRef Else, unsigned NumCases); 00685 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn, 00686 LLVMValueRef *Args, unsigned NumArgs, 00687 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, 00688 const char *Name); 00689 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef); 00690 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef); 00691 00692 /* Add a case to the switch instruction */ 00693 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal, 00694 LLVMBasicBlockRef Dest); 00695 00696 /* Arithmetic */ 00697 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00698 const char *Name); 00699 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00700 const char *Name); 00701 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00702 const char *Name); 00703 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00704 const char *Name); 00705 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00706 const char *Name); 00707 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00708 const char *Name); 00709 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00710 const char *Name); 00711 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00712 const char *Name); 00713 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00714 const char *Name); 00715 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00716 const char *Name); 00717 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00718 const char *Name); 00719 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00720 const char *Name); 00721 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00722 const char *Name); 00723 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00724 const char *Name); 00725 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00726 const char *Name); 00727 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00728 const char *Name); 00729 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00730 const char *Name); 00731 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00732 const char *Name); 00733 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00734 const char *Name); 00735 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, 00736 const char *Name); 00737 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name); 00738 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name); 00739 00740 /* Memory */ 00741 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 00742 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty, 00743 LLVMValueRef Val, const char *Name); 00744 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 00745 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty, 00746 LLVMValueRef Val, const char *Name); 00747 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal); 00748 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal, 00749 const char *Name); 00750 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr); 00751 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 00752 LLVMValueRef *Indices, unsigned NumIndices, 00753 const char *Name); 00754 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 00755 LLVMValueRef *Indices, unsigned NumIndices, 00756 const char *Name); 00757 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer, 00758 unsigned Idx, const char *Name); 00759 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str, 00760 const char *Name); 00761 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str, 00762 const char *Name); 00763 00764 /* Casts */ 00765 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val, 00766 LLVMTypeRef DestTy, const char *Name); 00767 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val, 00768 LLVMTypeRef DestTy, const char *Name); 00769 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val, 00770 LLVMTypeRef DestTy, const char *Name); 00771 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val, 00772 LLVMTypeRef DestTy, const char *Name); 00773 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val, 00774 LLVMTypeRef DestTy, const char *Name); 00775 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val, 00776 LLVMTypeRef DestTy, const char *Name); 00777 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val, 00778 LLVMTypeRef DestTy, const char *Name); 00779 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val, 00780 LLVMTypeRef DestTy, const char *Name); 00781 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val, 00782 LLVMTypeRef DestTy, const char *Name); 00783 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val, 00784 LLVMTypeRef DestTy, const char *Name); 00785 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val, 00786 LLVMTypeRef DestTy, const char *Name); 00787 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val, 00788 LLVMTypeRef DestTy, const char *Name); 00789 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 00790 LLVMTypeRef DestTy, const char *Name); 00791 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 00792 LLVMTypeRef DestTy, const char *Name); 00793 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val, 00794 LLVMTypeRef DestTy, const char *Name); 00795 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val, 00796 LLVMTypeRef DestTy, const char *Name); 00797 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, 00798 LLVMTypeRef DestTy, const char *Name); 00799 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val, 00800 LLVMTypeRef DestTy, const char *Name); 00801 00802 /* Comparisons */ 00803 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op, 00804 LLVMValueRef LHS, LLVMValueRef RHS, 00805 const char *Name); 00806 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op, 00807 LLVMValueRef LHS, LLVMValueRef RHS, 00808 const char *Name); 00809 00810 /* Miscellaneous instructions */ 00811 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name); 00812 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn, 00813 LLVMValueRef *Args, unsigned NumArgs, 00814 const char *Name); 00815 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If, 00816 LLVMValueRef Then, LLVMValueRef Else, 00817 const char *Name); 00818 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty, 00819 const char *Name); 00820 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal, 00821 LLVMValueRef Index, const char *Name); 00822 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal, 00823 LLVMValueRef EltVal, LLVMValueRef Index, 00824 const char *Name); 00825 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1, 00826 LLVMValueRef V2, LLVMValueRef Mask, 00827 const char *Name); 00828 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal, 00829 unsigned Index, const char *Name); 00830 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal, 00831 LLVMValueRef EltVal, unsigned Index, 00832 const char *Name); 00833 00834 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val, 00835 const char *Name); 00836 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val, 00837 const char *Name); 00838 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS, 00839 LLVMValueRef RHS, const char *Name); 00840 00841 00842 /*===-- Module providers --------------------------------------------------===*/ 00843 00844 /* Encapsulates the module M in a module provider, taking ownership of the 00845 * module. 00846 * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider. 00847 */ 00848 LLVMModuleProviderRef 00849 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M); 00850 00851 /* Destroys the module provider MP as well as the contained module. 00852 * See the destructor llvm::ModuleProvider::~ModuleProvider. 00853 */ 00854 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP); 00855 00856 00857 /*===-- Memory buffers ----------------------------------------------------===*/ 00858 00859 int LLVMCreateMemoryBufferWithContentsOfFile(const char *Path, 00860 LLVMMemoryBufferRef *OutMemBuf, 00861 char **OutMessage); 00862 int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf, 00863 char **OutMessage); 00864 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf); 00865 00866 00867 /*===-- Pass Managers -----------------------------------------------------===*/ 00868 00869 /** Constructs a new whole-module pass pipeline. This type of pipeline is 00870 suitable for link-time optimization and whole-module transformations. 00871 See llvm::PassManager::PassManager. */ 00872 LLVMPassManagerRef LLVMCreatePassManager(void); 00873 00874 /** Constructs a new function-by-function pass pipeline over the module 00875 provider. It does not take ownership of the module provider. This type of 00876 pipeline is suitable for code generation and JIT compilation tasks. 00877 See llvm::FunctionPassManager::FunctionPassManager. */ 00878 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP); 00879 00880 /** Initializes, executes on the provided module, and finalizes all of the 00881 passes scheduled in the pass manager. Returns 1 if any of the passes 00882 modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */ 00883 int LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M); 00884 00885 /** Initializes all of the function passes scheduled in the function pass 00886 manager. Returns 1 if any of the passes modified the module, 0 otherwise. 00887 See llvm::FunctionPassManager::doInitialization. */ 00888 int LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM); 00889 00890 /** Executes all of the function passes scheduled in the function pass manager 00891 on the provided function. Returns 1 if any of the passes modified the 00892 function, false otherwise. 00893 See llvm::FunctionPassManager::run(Function&). */ 00894 int LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F); 00895 00896 /** Finalizes all of the function passes scheduled in in the function pass 00897 manager. Returns 1 if any of the passes modified the module, 0 otherwise. 00898 See llvm::FunctionPassManager::doFinalization. */ 00899 int LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM); 00900 00901 /** Frees the memory of a pass pipeline. For function pipelines, does not free 00902 the module provider. 00903 See llvm::PassManagerBase::~PassManagerBase. */ 00904 void LLVMDisposePassManager(LLVMPassManagerRef PM); 00905 00906 00907 #ifdef __cplusplus 00908 } 00909 00910 namespace llvm { 00911 class ModuleProvider; 00912 class MemoryBuffer; 00913 class PassManagerBase; 00914 00915 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \ 00916 inline ty *unwrap(ref P) { \ 00917 return reinterpret_cast<ty*>(P); \ 00918 } \ 00919 \ 00920 inline ref wrap(const ty *P) { \ 00921 return reinterpret_cast<ref>(const_cast<ty*>(P)); \ 00922 } 00923 00924 #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref) \ 00925 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \ 00926 \ 00927 template<typename T> \ 00928 inline T *unwrap(ref P) { \ 00929 return cast<T>(unwrap(P)); \ 00930 } 00931 00932 #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref) \ 00933 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \ 00934 \ 00935 template<typename T> \ 00936 inline T *unwrap(ref P) { \ 00937 T *Q = dynamic_cast<T*>(unwrap(P)); \ 00938 assert(Q && "Invalid cast!"); \ 00939 return Q; \ 00940 } 00941 00942 DEFINE_ISA_CONVERSION_FUNCTIONS (Type, LLVMTypeRef ) 00943 DEFINE_ISA_CONVERSION_FUNCTIONS (Value, LLVMValueRef ) 00944 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef ) 00945 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef ) 00946 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef ) 00947 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder, LLVMTypeHandleRef ) 00948 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider, LLVMModuleProviderRef) 00949 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef ) 00950 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext, LLVMContextRef ) 00951 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef ) 00952 00953 #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS 00954 #undef DEFINE_ISA_CONVERSION_FUNCTIONS 00955 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS 00956 00957 /* Specialized opaque context conversions. 00958 */ 00959 inline LLVMContext **unwrap(LLVMContextRef* Tys) { 00960 return reinterpret_cast<LLVMContext**>(Tys); 00961 } 00962 00963 inline LLVMContextRef *wrap(const LLVMContext **Tys) { 00964 return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys)); 00965 } 00966 00967 /* Specialized opaque type conversions. 00968 */ 00969 inline Type **unwrap(LLVMTypeRef* Tys) { 00970 return reinterpret_cast<Type**>(Tys); 00971 } 00972 00973 inline LLVMTypeRef *wrap(const Type **Tys) { 00974 return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys)); 00975 } 00976 00977 /* Specialized opaque value conversions. 00978 */ 00979 inline Value **unwrap(LLVMValueRef *Vals) { 00980 return reinterpret_cast<Value**>(Vals); 00981 } 00982 00983 template<typename T> 00984 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) { 00985 #if DEBUG 00986 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I) 00987 cast<T>(*I); 00988 #endif 00989 return reinterpret_cast<T**>(Vals); 00990 } 00991 00992 inline LLVMValueRef *wrap(const Value **Vals) { 00993 return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals)); 00994 } 00995 } 00996 00997 #endif /* !defined(__cplusplus) */ 00998 00999 #endif /* !defined(LLVM_C_CORE_H) */