include/llvm-c/Core.h

   1 /*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
   2 |*                                                                            *|
   3 |*                     The LLVM Compiler Infrastructure                       *|
   4 |*                                                                            *|
   5 |* This file is distributed under the University of Illinois Open Source      *|
   6 |* License. See LICENSE.TXT for details.                                      *|
   7 |*                                                                            *|
   8 |*===----------------------------------------------------------------------===*|
   9 |*                                                                            *|
  10 |* This header declares the C interface to libLLVMCore.a, which implements    *|
  11 |* the LLVM intermediate representation.                                      *|
  12 |*                                                                            *|
  13 |* LLVM uses a polymorphic type hierarchy which C cannot represent, therefore *|
  14 |* parameters must be passed as base types. Despite the declared types, most  *|
  15 |* of the functions provided operate only on branches of the type hierarchy.  *|
  16 |* The declared parameter names are descriptive and specify which type is     *|
  17 |* required. Additionally, each type hierarchy is documented along with the   *|
  18 |* functions that operate upon it. For more detail, refer to LLVM's C++ code. *|
  19 |* If in doubt, refer to Core.cpp, which performs paramter downcasts in the   *|
  20 |* form unwrap<RequiredType>(Param).                                          *|
  21 |*                                                                            *|
  22 |* Many exotic languages can interoperate with C code but have a harder time  *|
  23 |* with C++ due to name mangling. So in addition to C, this interface enables *|
  24 |* tools written in such languages.                                           *|
  25 |*                                                                            *|
  26 |* When included into a C++ source file, also declares 'wrap' and 'unwrap'    *|
  27 |* helpers to perform opaque reference<-->pointer conversions. These helpers  *|
  28 |* are shorter and more tightly typed than writing the casts by hand when     *|
  29 |* authoring bindings. In assert builds, they will do runtime type checking.  *|
  30 |*                                                                            *|
  31 \*===----------------------------------------------------------------------===*/
  32
  33 #ifndef LLVM_C_CORE_H
  34 #define LLVM_C_CORE_H
  35
  36 #include "llvm/Support/DataTypes.h"
  37
  38 #ifdef __cplusplus
  39
  40 /* Need these includes to support the LLVM 'cast' template for the C++ 'wrap'
  41    and 'unwrap' conversion functions. */
  42 #include "llvm/Module.h"
  43 #include "llvm/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(DbgFuncStartInst)         \
 431             macro(DbgRegionEndInst)         \
 432             macro(DbgRegionStartInst)       \
 433             macro(DbgStopPointInst)         \
 434           macro(EHSelectorInst)             \
 435           macro(MemIntrinsic)               \
 436             macro(MemCpyInst)               \
 437             macro(MemMoveInst)              \
 438             macro(MemSetInst)               \
 439       macro(CmpInst)                        \
 440       macro(FCmpInst)                       \
 441       macro(ICmpInst)                       \
 442       macro(ExtractElementInst)             \
 443       macro(GetElementPtrInst)              \
 444       macro(InsertElementInst)              \
 445       macro(InsertValueInst)                \
 446       macro(PHINode)                        \
 447       macro(SelectInst)                     \
 448       macro(ShuffleVectorInst)              \
 449       macro(StoreInst)                      \
 450       macro(TerminatorInst)                 \
 451         macro(BranchInst)                   \
 452         macro(InvokeInst)                   \
 453         macro(ReturnInst)                   \
 454         macro(SwitchInst)                   \
 455         macro(UnreachableInst)              \
 456         macro(UnwindInst)                   \
 457     macro(UnaryInstruction)                 \
 458       macro(AllocationInst)                 \
 459         macro(AllocaInst)                   \
 460         macro(MallocInst)                   \
 461       macro(CastInst)                       \
 462         macro(BitCastInst)                  \
 463         macro(FPExtInst)                    \
 464         macro(FPToSIInst)                   \
 465         macro(FPToUIInst)                   \
 466         macro(FPTruncInst)                  \
 467         macro(IntToPtrInst)                 \
 468         macro(PtrToIntInst)                 \
 469         macro(SExtInst)                     \
 470         macro(SIToFPInst)                   \
 471         macro(TruncInst)                    \
 472         macro(UIToFPInst)                   \
 473         macro(ZExtInst)                     \
 474       macro(ExtractValueInst)               \
 475       macro(FreeInst)                       \
 476       macro(LoadInst)                       \
 477       macro(VAArgInst)
 478
 479 /* Operations on all values */
 480 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
 481 const char *LLVMGetValueName(LLVMValueRef Val);
 482 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
 483 void LLVMDumpValue(LLVMValueRef Val);
 484 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
 485
 486 /* Conversion functions. Return the input value if it is an instance of the
 487    specified class, otherwise NULL. See llvm::dyn_cast_or_null<>. */
 488 #define LLVM_DECLARE_VALUE_CAST(name) \
 489   LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
 490 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST)
 491
 492 /* Operations on Uses */
 493 LLVMUseIteratorRef LLVMGetFirstUse(LLVMValueRef Val);
 494 LLVMUseIteratorRef LLVMGetNextUse(LLVMUseIteratorRef U);
 495 LLVMValueRef LLVMGetUser(LLVMUseIteratorRef U);
 496 LLVMValueRef LLVMGetUsedValue(LLVMUseIteratorRef U);
 497
 498 /* Operations on Users */
 499 LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index);
 500
 501 /* Operations on constants of any type */
 502 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
 503 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
 504 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
 505 int LLVMIsConstant(LLVMValueRef Val);
 506 int LLVMIsNull(LLVMValueRef Val);
 507 int LLVMIsUndef(LLVMValueRef Val);
 508 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
 509
 510 /* Operations on scalar constants */
 511 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
 512                           int SignExtend);
 513 LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char *Text,
 514                                   uint8_t Radix);
 515 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char *Text,
 516                                          unsigned SLen, uint8_t Radix);
 517 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
 518 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
 519 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char *Text,
 520                                           unsigned SLen);
 521 unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal);
 522 long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal);
 523
 524
 525 /* Operations on composite constants */
 526 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
 527                                       unsigned Length, int DontNullTerminate);
 528 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
 529                                       LLVMValueRef *ConstantVals,
 530                                       unsigned Count, int Packed);
 531
 532 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
 533                              int DontNullTerminate);
 534 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
 535                             LLVMValueRef *ConstantVals, unsigned Length);
 536 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
 537                              int Packed);
 538 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
 539
 540 /* Constant expressions */
 541 LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal);
 542 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty);
 543 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
 544 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
 545 LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal);
 546 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
 547 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 548 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 549 LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 550 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 551 LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 552 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 553 LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 554 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 555 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 556 LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 557 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 558 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 559 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 560 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 561 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 562 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 563 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 564 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
 565                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 566 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
 567                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 568 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 569 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 570 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 571 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
 572                           LLVMValueRef *ConstantIndices, unsigned NumIndices);
 573 LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal,
 574                                   LLVMValueRef *ConstantIndices,
 575                                   unsigned NumIndices);
 576 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 577 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 578 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 579 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 580 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 581 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 582 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 583 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 584 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 585 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 586 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 587 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 588 LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,
 589                                     LLVMTypeRef ToType);
 590 LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,
 591                                     LLVMTypeRef ToType);
 592 LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,
 593                                      LLVMTypeRef ToType);
 594 LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal,
 595                                   LLVMTypeRef ToType);
 596 LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType,
 597                               unsigned isSigned);
 598 LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 599 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
 600                              LLVMValueRef ConstantIfTrue,
 601                              LLVMValueRef ConstantIfFalse);
 602 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
 603                                      LLVMValueRef IndexConstant);
 604 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
 605                                     LLVMValueRef ElementValueConstant,
 606                                     LLVMValueRef IndexConstant);
 607 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
 608                                     LLVMValueRef VectorBConstant,
 609                                     LLVMValueRef MaskConstant);
 610 LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList,
 611                                    unsigned NumIdx);
 612 LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
 613                                   LLVMValueRef ElementValueConstant,
 614                                   unsigned *IdxList, unsigned NumIdx);
 615 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty,
 616                                 const char *AsmString, const char *Constraints,
 617                                 int HasSideEffects);
 618
 619 /* Operations on global variables, functions, and aliases (globals) */
 620 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
 621 int LLVMIsDeclaration(LLVMValueRef Global);
 622 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
 623 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
 624 const char *LLVMGetSection(LLVMValueRef Global);
 625 void LLVMSetSection(LLVMValueRef Global, const char *Section);
 626 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
 627 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
 628 unsigned LLVMGetAlignment(LLVMValueRef Global);
 629 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
 630
 631 /* Operations on global variables */
 632 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
 633 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
 634 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
 635 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
 636 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
 637 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
 638 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
 639 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
 640 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
 641 int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
 642 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
 643 int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
 644 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
 645
 646 /* Operations on aliases */
 647 LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee,
 648                           const char *Name);
 649
 650 /* Operations on functions */
 651 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
 652                              LLVMTypeRef FunctionTy);
 653 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
 654 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
 655 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
 656 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
 657 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
 658 void LLVMDeleteFunction(LLVMValueRef Fn);
 659 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
 660 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
 661 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
 662 const char *LLVMGetGC(LLVMValueRef Fn);
 663 void LLVMSetGC(LLVMValueRef Fn, const char *Name);
 664 void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
 665 LLVMAttribute LLVMGetFunctionAttr(LLVMValueRef Fn);
 666 void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
 667
 668 /* Operations on parameters */
 669 unsigned LLVMCountParams(LLVMValueRef Fn);
 670 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
 671 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
 672 LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
 673 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
 674 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
 675 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
 676 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
 677 void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA);
 678 void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA);
 679 LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg);
 680 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align);
 681
 682 /* Operations on basic blocks */
 683 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
 684 int LLVMValueIsBasicBlock(LLVMValueRef Val);
 685 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
 686 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
 687 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
 688 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
 689 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
 690 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
 691 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
 692 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
 693 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
 694
 695 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
 696                                                 LLVMValueRef Fn,
 697                                                 const char *Name);
 698 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
 699                                                 LLVMBasicBlockRef BB,
 700                                                 const char *Name);
 701
 702 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
 703 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
 704                                        const char *Name);
 705 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
 706
 707 /* Operations on instructions */
 708 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
 709 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
 710 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
 711 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
 712 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
 713
 714 /* Operations on call sites */
 715 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
 716 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
 717 void LLVMAddInstrAttribute(LLVMValueRef Instr, unsigned index, LLVMAttribute);
 718 void LLVMRemoveInstrAttribute(LLVMValueRef Instr, unsigned index,
 719                               LLVMAttribute);
 720 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
 721                                 unsigned align);
 722
 723 /* Operations on call instructions (only) */
 724 int LLVMIsTailCall(LLVMValueRef CallInst);
 725 void LLVMSetTailCall(LLVMValueRef CallInst, int IsTailCall);
 726
 727 /* Operations on phi nodes */
 728 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
 729                      LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
 730 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
 731 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
 732 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
 733
 734 /*===-- Instruction builders ----------------------------------------------===*/
 735
 736 /* An instruction builder represents a point within a basic block, and is the
 737  * exclusive means of building instructions using the C interface.
 738  */
 739
 740 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C);
 741 LLVMBuilderRef LLVMCreateBuilder(void);
 742 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
 743                          LLVMValueRef Instr);
 744 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
 745 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
 746 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
 747 void LLVMClearInsertionPosition(LLVMBuilderRef Builder);
 748 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr);
 749 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
 750                                    const char *Name);
 751 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
 752
 753 /* Terminators */
 754 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
 755 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
 756 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
 757                                    unsigned N);
 758 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
 759 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
 760                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
 761 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
 762                              LLVMBasicBlockRef Else, unsigned NumCases);
 763 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
 764                              LLVMValueRef *Args, unsigned NumArgs,
 765                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
 766                              const char *Name);
 767 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
 768 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
 769
 770 /* Add a case to the switch instruction */
 771 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
 772                  LLVMBasicBlockRef Dest);
 773
 774 /* Arithmetic */
 775 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 776                           const char *Name);
 777 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 778                              const char *Name);
 779 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 780                            const char *Name);
 781 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 782                           const char *Name);
 783 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 784                            const char *Name);
 785 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 786                           const char *Name);
 787 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 788                            const char *Name);
 789 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 790                            const char *Name);
 791 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 792                            const char *Name);
 793 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 794                                 const char *Name);
 795 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 796                            const char *Name);
 797 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 798                            const char *Name);
 799 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 800                            const char *Name);
 801 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 802                            const char *Name);
 803 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 804                            const char *Name);
 805 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 806                            const char *Name);
 807 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 808                            const char *Name);
 809 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 810                           const char *Name);
 811 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 812                           const char *Name);
 813 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 814                           const char *Name);
 815 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 816 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 817 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 818
 819 /* Memory */
 820 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 821 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
 822                                   LLVMValueRef Val, const char *Name);
 823 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 824 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
 825                                   LLVMValueRef Val, const char *Name);
 826 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
 827 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
 828                            const char *Name);
 829 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
 830 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
 831                           LLVMValueRef *Indices, unsigned NumIndices,
 832                           const char *Name);
 833 LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
 834                                   LLVMValueRef *Indices, unsigned NumIndices,
 835                                   const char *Name);
 836 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
 837                                 unsigned Idx, const char *Name);
 838 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
 839                                    const char *Name);
 840 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
 841                                       const char *Name);
 842
 843 /* Casts */
 844 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
 845                             LLVMTypeRef DestTy, const char *Name);
 846 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
 847                            LLVMTypeRef DestTy, const char *Name);
 848 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
 849                            LLVMTypeRef DestTy, const char *Name);
 850 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
 851                              LLVMTypeRef DestTy, const char *Name);
 852 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
 853                              LLVMTypeRef DestTy, const char *Name);
 854 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
 855                              LLVMTypeRef DestTy, const char *Name);
 856 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
 857                              LLVMTypeRef DestTy, const char *Name);
 858 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
 859                               LLVMTypeRef DestTy, const char *Name);
 860 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
 861                             LLVMTypeRef DestTy, const char *Name);
 862 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
 863                                LLVMTypeRef DestTy, const char *Name);
 864 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
 865                                LLVMTypeRef DestTy, const char *Name);
 866 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
 867                               LLVMTypeRef DestTy, const char *Name);
 868 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
 869                                     LLVMTypeRef DestTy, const char *Name);
 870 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
 871                                     LLVMTypeRef DestTy, const char *Name);
 872 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef, LLVMValueRef Val,
 873                                      LLVMTypeRef DestTy, const char *Name);
 874 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef, LLVMValueRef Val,
 875                                   LLVMTypeRef DestTy, const char *Name);
 876 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef, LLVMValueRef Val,
 877                               LLVMTypeRef DestTy, const char *Name);
 878 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef, LLVMValueRef Val,
 879                              LLVMTypeRef DestTy, const char *Name);
 880
 881 /* Comparisons */
 882 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
 883                            LLVMValueRef LHS, LLVMValueRef RHS,
 884                            const char *Name);
 885 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
 886                            LLVMValueRef LHS, LLVMValueRef RHS,
 887                            const char *Name);
 888
 889 /* Miscellaneous instructions */
 890 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 891 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
 892                            LLVMValueRef *Args, unsigned NumArgs,
 893                            const char *Name);
 894 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
 895                              LLVMValueRef Then, LLVMValueRef Else,
 896                              const char *Name);
 897 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
 898                             const char *Name);
 899 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
 900                                      LLVMValueRef Index, const char *Name);
 901 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
 902                                     LLVMValueRef EltVal, LLVMValueRef Index,
 903                                     const char *Name);
 904 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
 905                                     LLVMValueRef V2, LLVMValueRef Mask,
 906                                     const char *Name);
 907 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
 908                                    unsigned Index, const char *Name);
 909 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
 910                                   LLVMValueRef EltVal, unsigned Index,
 911                                   const char *Name);
 912
 913 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef, LLVMValueRef Val,
 914                              const char *Name);
 915 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef, LLVMValueRef Val,
 916                                 const char *Name);
 917 LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef, LLVMValueRef LHS,
 918                               LLVMValueRef RHS, const char *Name);
 919
 920
 921 /*===-- Module providers --------------------------------------------------===*/
 922
 923 /* Encapsulates the module M in a module provider, taking ownership of the
 924  * module.
 925  * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
 926  */
 927 LLVMModuleProviderRef
 928 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
 929
 930 /* Destroys the module provider MP as well as the contained module.
 931  * See the destructor llvm::ModuleProvider::~ModuleProvider.
 932  */
 933 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP);
 934
 935
 936 /*===-- Memory buffers ----------------------------------------------------===*/
 937
 938 int LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
 939                                              LLVMMemoryBufferRef *OutMemBuf,
 940                                              char **OutMessage);
 941 int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
 942                                     char **OutMessage);
 943 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
 944
 945
 946 /*===-- Pass Managers -----------------------------------------------------===*/
 947
 948 /** Constructs a new whole-module pass pipeline. This type of pipeline is
 949     suitable for link-time optimization and whole-module transformations.
 950     See llvm::PassManager::PassManager. */
 951 LLVMPassManagerRef LLVMCreatePassManager(void);
 952
 953 /** Constructs a new function-by-function pass pipeline over the module
 954     provider. It does not take ownership of the module provider. This type of
 955     pipeline is suitable for code generation and JIT compilation tasks.
 956     See llvm::FunctionPassManager::FunctionPassManager. */
 957 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
 958
 959 /** Initializes, executes on the provided module, and finalizes all of the
 960     passes scheduled in the pass manager. Returns 1 if any of the passes
 961     modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */
 962 int LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
 963
 964 /** Initializes all of the function passes scheduled in the function pass
 965     manager. Returns 1 if any of the passes modified the module, 0 otherwise.
 966     See llvm::FunctionPassManager::doInitialization. */
 967 int LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
 968
 969 /** Executes all of the function passes scheduled in the function pass manager
 970     on the provided function. Returns 1 if any of the passes modified the
 971     function, false otherwise.
 972     See llvm::FunctionPassManager::run(Function&). */
 973 int LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
 974
 975 /** Finalizes all of the function passes scheduled in in the function pass
 976     manager. Returns 1 if any of the passes modified the module, 0 otherwise.
 977     See llvm::FunctionPassManager::doFinalization. */
 978 int LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
 979
 980 /** Frees the memory of a pass pipeline. For function pipelines, does not free
 981     the module provider.
 982     See llvm::PassManagerBase::~PassManagerBase. */
 983 void LLVMDisposePassManager(LLVMPassManagerRef PM);
 984
 985
 986 #ifdef __cplusplus
 987 }
 988
 989 namespace llvm {
 990   class ModuleProvider;
 991   class MemoryBuffer;
 992   class PassManagerBase;
 993
 994   #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)   \
 995     inline ty *unwrap(ref P) {                          \
 996       return reinterpret_cast<ty*>(P);                  \
 997     }                                                   \
 998                                                         \
 999     inline ref wrap(const ty *P) {                      \
1000       return reinterpret_cast<ref>(const_cast<ty*>(P)); \
1001     }
1002
1003   #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref)  \
1004     DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)         \
1005                                                         \
1006     template<typename T>                                \
1007     inline T *unwrap(ref P) {                           \
1008       return cast<T>(unwrap(P));                        \
1009     }
1010
1011   #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref)   \
1012     DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)         \
1013                                                         \
1014     template<typename T>                                \
1015     inline T *unwrap(ref P) {                           \
1016       T *Q = dynamic_cast<T*>(unwrap(P));               \
1017       assert(Q && "Invalid cast!");                     \
1018       return Q;                                         \
1019     }
1020
1021   DEFINE_ISA_CONVERSION_FUNCTIONS   (Type,               LLVMTypeRef          )
1022   DEFINE_ISA_CONVERSION_FUNCTIONS   (Value,              LLVMValueRef         )
1023   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module,             LLVMModuleRef        )
1024   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock,         LLVMBasicBlockRef    )
1025   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>,        LLVMBuilderRef       )
1026   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder,       LLVMTypeHandleRef    )
1027   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider,     LLVMModuleProviderRef)
1028   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer,       LLVMMemoryBufferRef  )
1029   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext,        LLVMContextRef       )
1030   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Use,                LLVMUseIteratorRef           )
1031   DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase,    LLVMPassManagerRef   )
1032
1033   #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS
1034   #undef DEFINE_ISA_CONVERSION_FUNCTIONS
1035   #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
1036
1037   /* Specialized opaque context conversions.
1038    */
1039   inline LLVMContext **unwrap(LLVMContextRef* Tys) {
1040     return reinterpret_cast<LLVMContext**>(Tys);
1041   }
1042
1043   inline LLVMContextRef *wrap(const LLVMContext **Tys) {
1044     return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys));
1045   }
1046
1047   /* Specialized opaque type conversions.
1048    */
1049   inline Type **unwrap(LLVMTypeRef* Tys) {
1050     return reinterpret_cast<Type**>(Tys);
1051   }
1052
1053   inline LLVMTypeRef *wrap(const Type **Tys) {
1054     return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
1055   }
1056
1057   /* Specialized opaque value conversions.
1058    */
1059   inline Value **unwrap(LLVMValueRef *Vals) {
1060     return reinterpret_cast<Value**>(Vals);
1061   }
1062
1063   template<typename T>
1064   inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
1065     #if DEBUG
1066     for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
1067       cast<T>(*I);
1068     #endif
1069     return reinterpret_cast<T**>(Vals);
1070   }
1071
1072   inline LLVMValueRef *wrap(const Value **Vals) {
1073     return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
1074   }
1075 }
1076
1077 #endif /* !defined(__cplusplus) */
1078
1079 #endif /* !defined(LLVM_C_CORE_H) */