include/llvm-c/Core.h

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