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