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