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