include/llvm-c/Core.h

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