LLVM API Documentation

Core.h

Go to the documentation of this file.
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) */