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