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 #include "llvm/Support/DataTypes.h"
  37
  38 #ifdef __cplusplus
  39
  40 /* Need these includes to support the LLVM 'cast' template for the C++ 'wrap'
  41    and 'unwrap' conversion functions. */
  42 #include "llvm/Module.h"
  43 #include "llvm/PassRegistry.h"
  44 #include "llvm/Support/IRBuilder.h"
  45
  46 extern "C" {
  47 #endif
  48
  49
  50 typedef int LLVMBool;
  51
  52 /* Opaque types. */
  53
  54 /**
  55  * The top-level container for all LLVM global data.  See the LLVMContext class.
  56  */
  57 typedef struct LLVMOpaqueContext *LLVMContextRef;
  58
  59 /**
  60  * The top-level container for all other LLVM Intermediate Representation (IR)
  61  * objects. See the llvm::Module class.
  62  */
  63 typedef struct LLVMOpaqueModule *LLVMModuleRef;
  64
  65 /**
  66  * Each value in the LLVM IR has a type, an LLVMTypeRef. See the llvm::Type
  67  * class.
  68  */
  69 typedef struct LLVMOpaqueType *LLVMTypeRef;
  70
  71 typedef struct LLVMOpaqueValue *LLVMValueRef;
  72 typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
  73 typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
  74
  75 /* Interface used to provide a module to JIT or interpreter.  This is now just a
  76  * synonym for llvm::Module, but we have to keep using the different type to
  77  * keep binary compatibility.
  78  */
  79 typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
  80
  81 /* Used to provide a module to JIT or interpreter.
  82  * See the llvm::MemoryBuffer class.
  83  */
  84 typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef;
  85
  86 /** See the llvm::PassManagerBase class. */
  87 typedef struct LLVMOpaquePassManager *LLVMPassManagerRef;
  88
  89 /** See the llvm::PassRegistry class. */
  90 typedef struct LLVMOpaquePassRegistry *LLVMPassRegistryRef;
  91
  92 /** Used to get the users and usees of a Value. See the llvm::Use class. */
  93 typedef struct LLVMOpaqueUse *LLVMUseRef;
  94
  95 typedef enum {
  96     LLVMZExtAttribute       = 1<<0,
  97     LLVMSExtAttribute       = 1<<1,
  98     LLVMNoReturnAttribute   = 1<<2,
  99     LLVMInRegAttribute      = 1<<3,
 100     LLVMStructRetAttribute  = 1<<4,
 101     LLVMNoUnwindAttribute   = 1<<5,
 102     LLVMNoAliasAttribute    = 1<<6,
 103     LLVMByValAttribute      = 1<<7,
 104     LLVMNestAttribute       = 1<<8,
 105     LLVMReadNoneAttribute   = 1<<9,
 106     LLVMReadOnlyAttribute   = 1<<10,
 107     LLVMNoInlineAttribute   = 1<<11,
 108     LLVMAlwaysInlineAttribute    = 1<<12,
 109     LLVMOptimizeForSizeAttribute = 1<<13,
 110     LLVMStackProtectAttribute    = 1<<14,
 111     LLVMStackProtectReqAttribute = 1<<15,
 112     LLVMAlignment = 31<<16,
 113     LLVMNoCaptureAttribute  = 1<<21,
 114     LLVMNoRedZoneAttribute  = 1<<22,
 115     LLVMNoImplicitFloatAttribute = 1<<23,
 116     LLVMNakedAttribute      = 1<<24,
 117     LLVMInlineHintAttribute = 1<<25,
 118     LLVMStackAlignment = 7<<26,
 119     LLVMReturnsTwice = 1 << 29,
 120     LLVMUWTable = 1 << 30,
 121     LLVMNonLazyBind = 1 << 31
 122 } LLVMAttribute;
 123
 124 typedef enum {
 125   /* Terminator Instructions */
 126   LLVMRet            = 1,
 127   LLVMBr             = 2,
 128   LLVMSwitch         = 3,
 129   LLVMIndirectBr     = 4,
 130   LLVMInvoke         = 5,
 131   /* removed 6 due to API changes */
 132   LLVMUnreachable    = 7,
 133
 134   /* Standard Binary Operators */
 135   LLVMAdd            = 8,
 136   LLVMFAdd           = 9,
 137   LLVMSub            = 10,
 138   LLVMFSub           = 11,
 139   LLVMMul            = 12,
 140   LLVMFMul           = 13,
 141   LLVMUDiv           = 14,
 142   LLVMSDiv           = 15,
 143   LLVMFDiv           = 16,
 144   LLVMURem           = 17,
 145   LLVMSRem           = 18,
 146   LLVMFRem           = 19,
 147
 148   /* Logical Operators */
 149   LLVMShl            = 20,
 150   LLVMLShr           = 21,
 151   LLVMAShr           = 22,
 152   LLVMAnd            = 23,
 153   LLVMOr             = 24,
 154   LLVMXor            = 25,
 155
 156   /* Memory Operators */
 157   LLVMAlloca         = 26,
 158   LLVMLoad           = 27,
 159   LLVMStore          = 28,
 160   LLVMGetElementPtr  = 29,
 161
 162   /* Cast Operators */
 163   LLVMTrunc          = 30,
 164   LLVMZExt           = 31,
 165   LLVMSExt           = 32,
 166   LLVMFPToUI         = 33,
 167   LLVMFPToSI         = 34,
 168   LLVMUIToFP         = 35,
 169   LLVMSIToFP         = 36,
 170   LLVMFPTrunc        = 37,
 171   LLVMFPExt          = 38,
 172   LLVMPtrToInt       = 39,
 173   LLVMIntToPtr       = 40,
 174   LLVMBitCast        = 41,
 175
 176   /* Other Operators */
 177   LLVMICmp           = 42,
 178   LLVMFCmp           = 43,
 179   LLVMPHI            = 44,
 180   LLVMCall           = 45,
 181   LLVMSelect         = 46,
 182   LLVMUserOp1        = 47,
 183   LLVMUserOp2        = 48,
 184   LLVMVAArg          = 49,
 185   LLVMExtractElement = 50,
 186   LLVMInsertElement  = 51,
 187   LLVMShuffleVector  = 52,
 188   LLVMExtractValue   = 53,
 189   LLVMInsertValue    = 54,
 190
 191   /* Atomic operators */
 192   LLVMFence          = 55,
 193   LLVMAtomicCmpXchg  = 56,
 194   LLVMAtomicRMW      = 57,
 195
 196   /* Exception Handling Operators */
 197   LLVMResume         = 58,
 198   LLVMLandingPad     = 59,
 199   LLVMUnwind         = 60
 200
 201
 202 } LLVMOpcode;
 203
 204 typedef enum {
 205   LLVMVoidTypeKind,        /**< type with no size */
 206   LLVMHalfTypeKind,        /**< 16 bit floating point type */
 207   LLVMFloatTypeKind,       /**< 32 bit floating point type */
 208   LLVMDoubleTypeKind,      /**< 64 bit floating point type */
 209   LLVMX86_FP80TypeKind,    /**< 80 bit floating point type (X87) */
 210   LLVMFP128TypeKind,       /**< 128 bit floating point type (112-bit mantissa)*/
 211   LLVMPPC_FP128TypeKind,   /**< 128 bit floating point type (two 64-bits) */
 212   LLVMLabelTypeKind,       /**< Labels */
 213   LLVMIntegerTypeKind,     /**< Arbitrary bit width integers */
 214   LLVMFunctionTypeKind,    /**< Functions */
 215   LLVMStructTypeKind,      /**< Structures */
 216   LLVMArrayTypeKind,       /**< Arrays */
 217   LLVMPointerTypeKind,     /**< Pointers */
 218   LLVMVectorTypeKind,      /**< SIMD 'packed' format, or other vector type */
 219   LLVMMetadataTypeKind,    /**< Metadata */
 220   LLVMX86_MMXTypeKind      /**< X86 MMX */
 221 } LLVMTypeKind;
 222
 223 typedef enum {
 224   LLVMExternalLinkage,    /**< Externally visible function */
 225   LLVMAvailableExternallyLinkage,
 226   LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
 227   LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
 228                             equivalent. */
 229   LLVMWeakAnyLinkage,     /**< Keep one copy of function when linking (weak) */
 230   LLVMWeakODRLinkage,     /**< Same, but only replaced by something
 231                             equivalent. */
 232   LLVMAppendingLinkage,   /**< Special purpose, only applies to global arrays */
 233   LLVMInternalLinkage,    /**< Rename collisions when linking (static
 234                                functions) */
 235   LLVMPrivateLinkage,     /**< Like Internal, but omit from symbol table */
 236   LLVMDLLImportLinkage,   /**< Function to be imported from DLL */
 237   LLVMDLLExportLinkage,   /**< Function to be accessible from DLL */
 238   LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
 239   LLVMGhostLinkage,       /**< Obsolete */
 240   LLVMCommonLinkage,      /**< Tentative definitions */
 241   LLVMLinkerPrivateLinkage, /**< Like Private, but linker removes. */
 242   LLVMLinkerPrivateWeakLinkage, /**< Like LinkerPrivate, but is weak. */
 243   LLVMLinkerPrivateWeakDefAutoLinkage /**< Like LinkerPrivateWeak, but possibly
 244                                            hidden. */
 245 } LLVMLinkage;
 246
 247 typedef enum {
 248   LLVMDefaultVisibility,  /**< The GV is visible */
 249   LLVMHiddenVisibility,   /**< The GV is hidden */
 250   LLVMProtectedVisibility /**< The GV is protected */
 251 } LLVMVisibility;
 252
 253 typedef enum {
 254   LLVMCCallConv           = 0,
 255   LLVMFastCallConv        = 8,
 256   LLVMColdCallConv        = 9,
 257   LLVMX86StdcallCallConv  = 64,
 258   LLVMX86FastcallCallConv = 65
 259 } LLVMCallConv;
 260
 261 typedef enum {
 262   LLVMIntEQ = 32, /**< equal */
 263   LLVMIntNE,      /**< not equal */
 264   LLVMIntUGT,     /**< unsigned greater than */
 265   LLVMIntUGE,     /**< unsigned greater or equal */
 266   LLVMIntULT,     /**< unsigned less than */
 267   LLVMIntULE,     /**< unsigned less or equal */
 268   LLVMIntSGT,     /**< signed greater than */
 269   LLVMIntSGE,     /**< signed greater or equal */
 270   LLVMIntSLT,     /**< signed less than */
 271   LLVMIntSLE      /**< signed less or equal */
 272 } LLVMIntPredicate;
 273
 274 typedef enum {
 275   LLVMRealPredicateFalse, /**< Always false (always folded) */
 276   LLVMRealOEQ,            /**< True if ordered and equal */
 277   LLVMRealOGT,            /**< True if ordered and greater than */
 278   LLVMRealOGE,            /**< True if ordered and greater than or equal */
 279   LLVMRealOLT,            /**< True if ordered and less than */
 280   LLVMRealOLE,            /**< True if ordered and less than or equal */
 281   LLVMRealONE,            /**< True if ordered and operands are unequal */
 282   LLVMRealORD,            /**< True if ordered (no nans) */
 283   LLVMRealUNO,            /**< True if unordered: isnan(X) | isnan(Y) */
 284   LLVMRealUEQ,            /**< True if unordered or equal */
 285   LLVMRealUGT,            /**< True if unordered or greater than */
 286   LLVMRealUGE,            /**< True if unordered, greater than, or equal */
 287   LLVMRealULT,            /**< True if unordered or less than */
 288   LLVMRealULE,            /**< True if unordered, less than, or equal */
 289   LLVMRealUNE,            /**< True if unordered or not equal */
 290   LLVMRealPredicateTrue   /**< Always true (always folded) */
 291 } LLVMRealPredicate;
 292
 293 typedef enum {
 294   LLVMLandingPadCatch,    /**< A catch clause   */
 295   LLVMLandingPadFilter    /**< A filter clause  */
 296 } LLVMLandingPadClauseTy;
 297
 298 void LLVMInitializeCore(LLVMPassRegistryRef R);
 299
 300
 301 /*===-- Error handling ----------------------------------------------------===*/
 302
 303 void LLVMDisposeMessage(char *Message);
 304
 305
 306 /*===-- Contexts ----------------------------------------------------------===*/
 307
 308 /* Create and destroy contexts. */
 309 LLVMContextRef LLVMContextCreate(void);
 310 LLVMContextRef LLVMGetGlobalContext(void);
 311 void LLVMContextDispose(LLVMContextRef C);
 312
 313 unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char* Name,
 314                                   unsigned SLen);
 315 unsigned LLVMGetMDKindID(const char* Name, unsigned SLen);
 316
 317 /*===-- Modules -----------------------------------------------------------===*/
 318
 319 /* Create and destroy modules. */
 320 /** See llvm::Module::Module. */
 321 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
 322 LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
 323                                                 LLVMContextRef C);
 324
 325 /** See llvm::Module::~Module. */
 326 void LLVMDisposeModule(LLVMModuleRef M);
 327
 328 /** Data layout. See Module::getDataLayout. */
 329 const char *LLVMGetDataLayout(LLVMModuleRef M);
 330 void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple);
 331
 332 /** Target triple. See Module::getTargetTriple. */
 333 const char *LLVMGetTarget(LLVMModuleRef M);
 334 void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
 335
 336 /** See Module::dump. */
 337 void LLVMDumpModule(LLVMModuleRef M);
 338
 339 /** See Module::setModuleInlineAsm. */
 340 void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm);
 341
 342 /** See Module::getContext. */
 343 LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M);
 344
 345 /*===-- Types -------------------------------------------------------------===*/
 346
 347 /* LLVM types conform to the following hierarchy:
 348  *
 349  *   types:
 350  *     integer type
 351  *     real type
 352  *     function type
 353  *     sequence types:
 354  *       array type
 355  *       pointer type
 356  *       vector type
 357  *     void type
 358  *     label type
 359  *     opaque type
 360  */
 361
 362 /** See llvm::LLVMTypeKind::getTypeID. */
 363 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
 364 LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty);
 365
 366 /** See llvm::LLVMType::getContext. */
 367 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty);
 368
 369 /* Operations on integer types */
 370 LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C);
 371 LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C);
 372 LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C);
 373 LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C);
 374 LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C);
 375 LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits);
 376
 377 LLVMTypeRef LLVMInt1Type(void);
 378 LLVMTypeRef LLVMInt8Type(void);
 379 LLVMTypeRef LLVMInt16Type(void);
 380 LLVMTypeRef LLVMInt32Type(void);
 381 LLVMTypeRef LLVMInt64Type(void);
 382 LLVMTypeRef LLVMIntType(unsigned NumBits);
 383 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
 384
 385 /* Operations on real types */
 386 LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C);
 387 LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C);
 388 LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C);
 389 LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C);
 390 LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C);
 391 LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C);
 392
 393 LLVMTypeRef LLVMHalfType(void);
 394 LLVMTypeRef LLVMFloatType(void);
 395 LLVMTypeRef LLVMDoubleType(void);
 396 LLVMTypeRef LLVMX86FP80Type(void);
 397 LLVMTypeRef LLVMFP128Type(void);
 398 LLVMTypeRef LLVMPPCFP128Type(void);
 399
 400 /* Operations on function types */
 401 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
 402                              LLVMTypeRef *ParamTypes, unsigned ParamCount,
 403                              LLVMBool IsVarArg);
 404 LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
 405 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
 406 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
 407 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
 408
 409 /* Operations on struct types */
 410 LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
 411                                     unsigned ElementCount, LLVMBool Packed);
 412 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
 413                            LLVMBool Packed);
 414 LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name);
 415 const char *LLVMGetStructName(LLVMTypeRef Ty);
 416 void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes,
 417                        unsigned ElementCount, LLVMBool Packed);
 418
 419 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
 420 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
 421 LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy);
 422 LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy);
 423
 424 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name);
 425
 426 /* Operations on array, pointer, and vector types (sequence types) */
 427 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
 428 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
 429 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
 430
 431 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
 432 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
 433 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
 434 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
 435
 436 /* Operations on other types */
 437 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C);
 438 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C);
 439 LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C);
 440
 441 LLVMTypeRef LLVMVoidType(void);
 442 LLVMTypeRef LLVMLabelType(void);
 443 LLVMTypeRef LLVMX86MMXType(void);
 444
 445 /*===-- Values ------------------------------------------------------------===*/
 446
 447 /* The bulk of LLVM's object model consists of values, which comprise a very
 448  * rich type hierarchy.
 449  */
 450
 451 #define LLVM_FOR_EACH_VALUE_SUBCLASS(macro) \
 452   macro(Argument)                           \
 453   macro(BasicBlock)                         \
 454   macro(InlineAsm)                          \
 455   macro(MDNode)                             \
 456   macro(MDString)                           \
 457   macro(User)                               \
 458     macro(Constant)                         \
 459       macro(BlockAddress)                   \
 460       macro(ConstantAggregateZero)          \
 461       macro(ConstantArray)                  \
 462       macro(ConstantExpr)                   \
 463       macro(ConstantFP)                     \
 464       macro(ConstantInt)                    \
 465       macro(ConstantPointerNull)            \
 466       macro(ConstantStruct)                 \
 467       macro(ConstantVector)                 \
 468       macro(GlobalValue)                    \
 469         macro(Function)                     \
 470         macro(GlobalAlias)                  \
 471         macro(GlobalVariable)               \
 472       macro(UndefValue)                     \
 473     macro(Instruction)                      \
 474       macro(BinaryOperator)                 \
 475       macro(CallInst)                       \
 476         macro(IntrinsicInst)                \
 477           macro(DbgInfoIntrinsic)           \
 478             macro(DbgDeclareInst)           \
 479           macro(EHExceptionInst)            \
 480           macro(EHSelectorInst)             \
 481           macro(MemIntrinsic)               \
 482             macro(MemCpyInst)               \
 483             macro(MemMoveInst)              \
 484             macro(MemSetInst)               \
 485       macro(CmpInst)                        \
 486         macro(FCmpInst)                     \
 487         macro(ICmpInst)                     \
 488       macro(ExtractElementInst)             \
 489       macro(GetElementPtrInst)              \
 490       macro(InsertElementInst)              \
 491       macro(InsertValueInst)                \
 492       macro(LandingPadInst)                 \
 493       macro(PHINode)                        \
 494       macro(SelectInst)                     \
 495       macro(ShuffleVectorInst)              \
 496       macro(StoreInst)                      \
 497       macro(TerminatorInst)                 \
 498         macro(BranchInst)                   \
 499         macro(IndirectBrInst)               \
 500         macro(InvokeInst)                   \
 501         macro(ReturnInst)                   \
 502         macro(SwitchInst)                   \
 503         macro(UnreachableInst)              \
 504         macro(ResumeInst)                   \
 505     macro(UnaryInstruction)                 \
 506       macro(AllocaInst)                     \
 507       macro(CastInst)                       \
 508         macro(BitCastInst)                  \
 509         macro(FPExtInst)                    \
 510         macro(FPToSIInst)                   \
 511         macro(FPToUIInst)                   \
 512         macro(FPTruncInst)                  \
 513         macro(IntToPtrInst)                 \
 514         macro(PtrToIntInst)                 \
 515         macro(SExtInst)                     \
 516         macro(SIToFPInst)                   \
 517         macro(TruncInst)                    \
 518         macro(UIToFPInst)                   \
 519         macro(ZExtInst)                     \
 520       macro(ExtractValueInst)               \
 521       macro(LoadInst)                       \
 522       macro(VAArgInst)
 523
 524 /* Operations on all values */
 525 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
 526 const char *LLVMGetValueName(LLVMValueRef Val);
 527 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
 528 void LLVMDumpValue(LLVMValueRef Val);
 529 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
 530 int LLVMHasMetadata(LLVMValueRef Val);
 531 LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID);
 532 void LLVMSetMetadata(LLVMValueRef Val, unsigned KindID, LLVMValueRef Node);
 533
 534 /* Conversion functions. Return the input value if it is an instance of the
 535    specified class, otherwise NULL. See llvm::dyn_cast_or_null<>. */
 536 #define LLVM_DECLARE_VALUE_CAST(name) \
 537   LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
 538 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST)
 539
 540 /* Operations on Uses */
 541 LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val);
 542 LLVMUseRef LLVMGetNextUse(LLVMUseRef U);
 543 LLVMValueRef LLVMGetUser(LLVMUseRef U);
 544 LLVMValueRef LLVMGetUsedValue(LLVMUseRef U);
 545
 546 /* Operations on Users and metadata */
 547 LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index);
 548 void LLVMSetOperand(LLVMValueRef User, unsigned Index, LLVMValueRef Val);
 549 int LLVMGetNumOperands(LLVMValueRef Val);
 550
 551 /* Operations on constants of any type */
 552 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
 553 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
 554 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
 555 LLVMBool LLVMIsConstant(LLVMValueRef Val);
 556 LLVMBool LLVMIsNull(LLVMValueRef Val);
 557 LLVMBool LLVMIsUndef(LLVMValueRef Val);
 558 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
 559
 560 /* Operations on metadata */
 561 LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str,
 562                                    unsigned SLen);
 563 LLVMValueRef LLVMMDString(const char *Str, unsigned SLen);
 564 LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals,
 565                                  unsigned Count);
 566 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count);
 567 const char  *LLVMGetMDString(LLVMValueRef V, unsigned* Len);
 568 unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char* name);
 569 void LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char* name, LLVMValueRef *Dest);
 570 void LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char* name,
 571                                  LLVMValueRef Val);
 572
 573 /* Operations on scalar constants */
 574 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
 575                           LLVMBool SignExtend);
 576 LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy,
 577                                               unsigned NumWords,
 578                                               const uint64_t Words[]);
 579 LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text,
 580                                   uint8_t Radix);
 581 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text,
 582                                          unsigned SLen, uint8_t Radix);
 583 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
 584 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
 585 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text,
 586                                           unsigned SLen);
 587 unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal);
 588 long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal);
 589
 590
 591 /* Operations on composite constants */
 592 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
 593                                       unsigned Length, LLVMBool DontNullTerminate);
 594 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
 595                                       LLVMValueRef *ConstantVals,
 596                                       unsigned Count, LLVMBool Packed);
 597
 598 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
 599                              LLVMBool DontNullTerminate);
 600 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
 601                             LLVMValueRef *ConstantVals, unsigned Length);
 602 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
 603                              LLVMBool Packed);
 604 LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy,
 605                                   LLVMValueRef *ConstantVals,
 606                                   unsigned Count);
 607 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
 608
 609 /* Constant expressions */
 610 LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal);
 611 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty);
 612 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
 613 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
 614 LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal);
 615 LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal);
 616 LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal);
 617 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
 618 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 619 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 620 LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 621 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 622 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 623 LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 624 LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 625 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 626 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 627 LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 628 LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 629 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 630 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 631 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 632 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 633 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 634 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 635 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 636 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 637 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 638 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 639 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 640 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
 641                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 642 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
 643                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 644 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 645 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 646 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 647 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
 648                           LLVMValueRef *ConstantIndices, unsigned NumIndices);
 649 LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
 650                                   LLVMValueRef *ConstantIndices,
 651                                   unsigned NumIndices);
 652 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 653 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 654 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 655 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 656 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 657 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 658 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 659 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 660 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 661 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 662 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 663 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 664 LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,
 665                                     LLVMTypeRef ToType);
 666 LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,
 667                                     LLVMTypeRef ToType);
 668 LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,
 669                                      LLVMTypeRef ToType);
 670 LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal,
 671                                   LLVMTypeRef ToType);
 672 LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType,
 673                               LLVMBool isSigned);
 674 LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 675 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
 676                              LLVMValueRef ConstantIfTrue,
 677                              LLVMValueRef ConstantIfFalse);
 678 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
 679                                      LLVMValueRef IndexConstant);
 680 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
 681                                     LLVMValueRef ElementValueConstant,
 682                                     LLVMValueRef IndexConstant);
 683 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
 684                                     LLVMValueRef VectorBConstant,
 685                                     LLVMValueRef MaskConstant);
 686 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
 687                                    unsigned NumIdx);
 688 LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
 689                                   LLVMValueRef ElementValueConstant,
 690                                   unsigned *IdxList, unsigned NumIdx);
 691 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty,
 692                                 const char *AsmString, const char *Constraints,
 693                                 LLVMBool HasSideEffects, LLVMBool IsAlignStack);
 694 LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB);
 695
 696 /* Operations on global variables, functions, and aliases (globals) */
 697 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
 698 LLVMBool LLVMIsDeclaration(LLVMValueRef Global);
 699 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
 700 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
 701 const char *LLVMGetSection(LLVMValueRef Global);
 702 void LLVMSetSection(LLVMValueRef Global, const char *Section);
 703 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
 704 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
 705 unsigned LLVMGetAlignment(LLVMValueRef Global);
 706 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
 707
 708 /* Operations on global variables */
 709 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
 710 LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty,
 711                                          const char *Name,
 712                                          unsigned AddressSpace);
 713 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
 714 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
 715 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
 716 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
 717 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
 718 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
 719 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
 720 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
 721 LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar);
 722 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal);
 723 LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
 724 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant);
 725
 726 /* Operations on aliases */
 727 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
 728                           const char *Name);
 729
 730 /* Operations on functions */
 731 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
 732                              LLVMTypeRef FunctionTy);
 733 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
 734 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
 735 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
 736 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
 737 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
 738 void LLVMDeleteFunction(LLVMValueRef Fn);
 739 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
 740 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
 741 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
 742 const char *LLVMGetGC(LLVMValueRef Fn);
 743 void LLVMSetGC(LLVMValueRef Fn, const char *Name);
 744 void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
 745 LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn);
 746 void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
 747
 748 /* Operations on parameters */
 749 unsigned LLVMCountParams(LLVMValueRef Fn);
 750 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
 751 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
 752 LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
 753 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
 754 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
 755 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
 756 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
 757 void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA);
 758 void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA);
 759 LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg);
 760 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align);
 761
 762 /* Operations on basic blocks */
 763 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
 764 LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val);
 765 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
 766 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
 767 LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB);
 768 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
 769 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
 770 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
 771 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
 772 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
 773 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
 774 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
 775
 776 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
 777                                                 LLVMValueRef Fn,
 778                                                 const char *Name);
 779 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
 780                                                 LLVMBasicBlockRef BB,
 781                                                 const char *Name);
 782
 783 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
 784 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
 785                                        const char *Name);
 786 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
 787 void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BB);
 788
 789 void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
 790 void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos);
 791
 792 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
 793 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
 794
 795 /* Operations on instructions */
 796 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
 797 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
 798 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
 799 void LLVMInstructionEraseFromParent(LLVMValueRef Inst);
 800 LLVMOpcode   LLVMGetInstructionOpcode(LLVMValueRef Inst);
 801 LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst);
 802
 803 /* Operations on call sites */
 804 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
 805 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
 806 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
 807 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
 808                               LLVMAttribute);
 809 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
 810                                 unsigned align);
 811
 812 /* Operations on call instructions (only) */
 813 LLVMBool LLVMIsTailCall(LLVMValueRef CallInst);
 814 void LLVMSetTailCall(LLVMValueRef CallInst, LLVMBool IsTailCall);
 815
 816 /* Operations on switch instructions (only) */
 817 LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef SwitchInstr);
 818
 819 /* Operations on phi nodes */
 820 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
 821                      LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
 822 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
 823 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
 824 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
 825
 826 /*===-- Instruction builders ----------------------------------------------===*/
 827
 828 /* An instruction builder represents a point within a basic block, and is the
 829  * exclusive means of building instructions using the C interface.
 830  */
 831
 832 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
 833 LLVMBuilderRef LLVMCreateBuilder(void);
 834 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
 835                          LLVMValueRef Instr);
 836 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
 837 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
 838 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
 839 void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
 840 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
 841 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
 842                                    const char *Name);
 843 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
 844
 845 /* Metadata */
 846 void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L);
 847 LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder);
 848 void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst);
 849
 850 /* Terminators */
 851 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
 852 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
 853 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
 854                                    unsigned N);
 855 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
 856 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
 857                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
 858 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
 859                              LLVMBasicBlockRef Else, unsigned NumCases);
 860 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
 861                                  unsigned NumDests);
 862 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
 863                              LLVMValueRef *Args, unsigned NumArgs,
 864                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
 865                              const char *Name);
 866 LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
 867                                  LLVMValueRef PersFn, unsigned NumClauses,
 868                                  const char *Name);
 869 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn);
 870 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
 871
 872 /* Add a case to the switch instruction */
 873 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
 874                  LLVMBasicBlockRef Dest);
 875
 876 /* Add a destination to the indirectbr instruction */
 877 void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest);
 878
 879 /* Add a catch or filter clause to the landingpad instruction */
 880 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal);
 881
 882 /* Set the 'cleanup' flag in the landingpad instruction */
 883 void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val);
 884
 885 /* Arithmetic */
 886 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 887                           const char *Name);
 888 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 889                              const char *Name);
 890 LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 891                              const char *Name);
 892 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 893                            const char *Name);
 894 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 895                           const char *Name);
 896 LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 897                              const char *Name);
 898 LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 899                              const char *Name);
 900 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 901                            const char *Name);
 902 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 903                           const char *Name);
 904 LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 905                              const char *Name);
 906 LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 907                              const char *Name);
 908 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 909                            const char *Name);
 910 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 911                            const char *Name);
 912 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 913                            const char *Name);
 914 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 915                                 const char *Name);
 916 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 917                            const char *Name);
 918 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 919                            const char *Name);
 920 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 921                            const char *Name);
 922 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 923                            const char *Name);
 924 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 925                            const char *Name);
 926 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 927                            const char *Name);
 928 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 929                            const char *Name);
 930 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 931                           const char *Name);
 932 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 933                           const char *Name);
 934 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 935                           const char *Name);
 936 LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
 937                             LLVMValueRef LHS, LLVMValueRef RHS,
 938                             const char *Name);
 939 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 940 LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
 941                              const char *Name);
 942 LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
 943                              const char *Name);
 944 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 945 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 946
 947 /* Memory */
 948 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 949 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
 950                                   LLVMValueRef Val, const char *Name);
 951 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 952 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
 953                                   LLVMValueRef Val, const char *Name);
 954 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
 955 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
 956                            const char *Name);
 957 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
 958 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
 959                           LLVMValueRef *Indices, unsigned NumIndices,
 960                           const char *Name);
 961 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
 962                                   LLVMValueRef *Indices, unsigned NumIndices,
 963                                   const char *Name);
 964 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
 965                                 unsigned Idx, const char *Name);
 966 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
 967                                    const char *Name);
 968 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
 969                                       const char *Name);
 970
 971 /* Casts */
 972 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
 973                             LLVMTypeRef DestTy, const char *Name);
 974 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
 975                            LLVMTypeRef DestTy, const char *Name);
 976 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
 977                            LLVMTypeRef DestTy, const char *Name);
 978 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
 979                              LLVMTypeRef DestTy, const char *Name);
 980 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
 981                              LLVMTypeRef DestTy, const char *Name);
 982 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
 983                              LLVMTypeRef DestTy, const char *Name);
 984 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
 985                              LLVMTypeRef DestTy, const char *Name);
 986 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
 987                               LLVMTypeRef DestTy, const char *Name);
 988 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
 989                             LLVMTypeRef DestTy, const char *Name);
 990 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
 991                                LLVMTypeRef DestTy, const char *Name);
 992 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
 993                                LLVMTypeRef DestTy, const char *Name);
 994 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
 995                               LLVMTypeRef DestTy, const char *Name);
 996 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
 997                                     LLVMTypeRef DestTy, const char *Name);
 998 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
 999                                     LLVMTypeRef DestTy, const char *Name);
1000 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
1001                                      LLVMTypeRef DestTy, const char *Name);
1002 LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
1003                            LLVMTypeRef DestTy, const char *Name);
1004 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
1005                                   LLVMTypeRef DestTy, const char *Name);
1006 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val, /*Signed cast!*/
1007                               LLVMTypeRef DestTy, const char *Name);
1008 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
1009                              LLVMTypeRef DestTy, const char *Name);
1010
1011 /* Comparisons */
1012 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
1013                            LLVMValueRef LHS, LLVMValueRef RHS,
1014                            const char *Name);
1015 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
1016                            LLVMValueRef LHS, LLVMValueRef RHS,
1017                            const char *Name);
1018
1019 /* Miscellaneous instructions */
1020 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
1021 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
1022                            LLVMValueRef *Args, unsigned NumArgs,
1023                            const char *Name);
1024 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
1025                              LLVMValueRef Then, LLVMValueRef Else,
1026                              const char *Name);
1027 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
1028                             const char *Name);
1029 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
1030                                      LLVMValueRef Index, const char *Name);
1031 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
1032                                     LLVMValueRef EltVal, LLVMValueRef Index,
1033                                     const char *Name);
1034 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
1035                                     LLVMValueRef V2, LLVMValueRef Mask,
1036                                     const char *Name);
1037 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
1038                                    unsigned Index, const char *Name);
1039 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
1040                                   LLVMValueRef EltVal, unsigned Index,
1041                                   const char *Name);
1042
1043 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
1044                              const char *Name);
1045 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
1046                                 const char *Name);
1047 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
1048                               LLVMValueRef RHS, const char *Name);
1049
1050
1051 /*===-- Module providers --------------------------------------------------===*/
1052
1053 /* Changes the type of M so it can be passed to FunctionPassManagers and the
1054  * JIT.  They take ModuleProviders for historical reasons.
1055  */
1056 LLVMModuleProviderRef
1057 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
1058
1059 /* Destroys the module M.
1060  */
1061 void LLVMDisposeModuleProvider(LLVMModuleProviderRef M);
1062
1063
1064 /*===-- Memory buffers ----------------------------------------------------===*/
1065
1066 LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
1067                                                   LLVMMemoryBufferRef *OutMemBuf,
1068                                                   char **OutMessage);
1069 LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
1070                                          char **OutMessage);
1071 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
1072
1073 /*===-- Pass Registry -----------------------------------------------------===*/
1074
1075 /** Return the global pass registry, for use with initialization functions.
1076     See llvm::PassRegistry::getPassRegistry. */
1077 LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void);
1078
1079 /*===-- Pass Managers -----------------------------------------------------===*/
1080
1081 /** Constructs a new whole-module pass pipeline. This type of pipeline is
1082     suitable for link-time optimization and whole-module transformations.
1083     See llvm::PassManager::PassManager. */
1084 LLVMPassManagerRef LLVMCreatePassManager(void);
1085
1086 /** Constructs a new function-by-function pass pipeline over the module
1087     provider. It does not take ownership of the module provider. This type of
1088     pipeline is suitable for code generation and JIT compilation tasks.
1089     See llvm::FunctionPassManager::FunctionPassManager. */
1090 LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M);
1091
1092 /** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */
1093 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
1094
1095 /** Initializes, executes on the provided module, and finalizes all of the
1096     passes scheduled in the pass manager. Returns 1 if any of the passes
1097     modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */
1098 LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
1099
1100 /** Initializes all of the function passes scheduled in the function pass
1101     manager. Returns 1 if any of the passes modified the module, 0 otherwise.
1102     See llvm::FunctionPassManager::doInitialization. */
1103 LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
1104
1105 /** Executes all of the function passes scheduled in the function pass manager
1106     on the provided function. Returns 1 if any of the passes modified the
1107     function, false otherwise.
1108     See llvm::FunctionPassManager::run(Function&). */
1109 LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
1110
1111 /** Finalizes all of the function passes scheduled in in the function pass
1112     manager. Returns 1 if any of the passes modified the module, 0 otherwise.
1113     See llvm::FunctionPassManager::doFinalization. */
1114 LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
1115
1116 /** Frees the memory of a pass pipeline. For function pipelines, does not free
1117     the module provider.
1118     See llvm::PassManagerBase::~PassManagerBase. */
1119 void LLVMDisposePassManager(LLVMPassManagerRef PM);
1120
1121
1122 #ifdef __cplusplus
1123 }
1124
1125 namespace llvm {
1126   class MemoryBuffer;
1127   class PassManagerBase;
1128
1129   #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)   \
1130     inline ty *unwrap(ref P) {                          \
1131       return reinterpret_cast<ty*>(P);                  \
1132     }                                                   \
1133                                                         \
1134     inline ref wrap(const ty *P) {                      \
1135       return reinterpret_cast<ref>(const_cast<ty*>(P)); \
1136     }
1137
1138   #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref)  \
1139     DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)         \
1140                                                         \
1141     template<typename T>                                \
1142     inline T *unwrap(ref P) {                           \
1143       return cast<T>(unwrap(P));                        \
1144     }
1145
1146   #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref)   \
1147     DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)         \
1148                                                         \
1149     template<typename T>                                \
1150     inline T *unwrap(ref P) {                           \
1151       T *Q = (T*)unwrap(P);                             \
1152       assert(Q && "Invalid cast!");                     \
1153       return Q;                                         \
1154     }
1155
1156   DEFINE_ISA_CONVERSION_FUNCTIONS   (Type,               LLVMTypeRef          )
1157   DEFINE_ISA_CONVERSION_FUNCTIONS   (Value,              LLVMValueRef         )
1158   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module,             LLVMModuleRef        )
1159   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock,         LLVMBasicBlockRef    )
1160   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>,        LLVMBuilderRef       )
1161   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer,       LLVMMemoryBufferRef  )
1162   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext,        LLVMContextRef       )
1163   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Use,                LLVMUseRef           )
1164   DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase,    LLVMPassManagerRef   )
1165   DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassRegistry,       LLVMPassRegistryRef  )
1166   /* LLVMModuleProviderRef exists for historical reasons, but now just holds a
1167    * Module.
1168    */
1169   inline Module *unwrap(LLVMModuleProviderRef MP) {
1170     return reinterpret_cast<Module*>(MP);
1171   }
1172
1173   #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS
1174   #undef DEFINE_ISA_CONVERSION_FUNCTIONS
1175   #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
1176
1177   /* Specialized opaque context conversions.
1178    */
1179   inline LLVMContext **unwrap(LLVMContextRef* Tys) {
1180     return reinterpret_cast<LLVMContext**>(Tys);
1181   }
1182
1183   inline LLVMContextRef *wrap(const LLVMContext **Tys) {
1184     return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys));
1185   }
1186
1187   /* Specialized opaque type conversions.
1188    */
1189   inline Type **unwrap(LLVMTypeRef* Tys) {
1190     return reinterpret_cast<Type**>(Tys);
1191   }
1192
1193   inline LLVMTypeRef *wrap(Type **Tys) {
1194     return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
1195   }
1196
1197   /* Specialized opaque value conversions.
1198    */
1199   inline Value **unwrap(LLVMValueRef *Vals) {
1200     return reinterpret_cast<Value**>(Vals);
1201   }
1202
1203   template<typename T>
1204   inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
1205     #if DEBUG
1206     for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
1207       cast<T>(*I);
1208     #endif
1209     (void)Length;
1210     return reinterpret_cast<T**>(Vals);
1211   }
1212
1213   inline LLVMValueRef *wrap(const Value **Vals) {
1214     return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
1215   }
1216 }
1217
1218 #endif /* !defined(__cplusplus) */
1219
1220 #endif /* !defined(LLVM_C_CORE_H) */