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