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