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