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