include/llvm-c/Core.h

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