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