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 other LLVM Intermediate Representation (IR)
  51  * objects. See the llvm::Module class.
  52  */
  53 typedef struct LLVMOpaqueModule *LLVMModuleRef;
  54
  55 /**
  56  * Each value in the LLVM IR has a type, an LLVMTypeRef. See the llvm::Type
  57  * class.
  58  */
  59 typedef struct LLVMOpaqueType *LLVMTypeRef;
  60
  61 /**
  62  * When building recursive types using LLVMRefineType, LLVMTypeRef values may
  63  * become invalid; use LLVMTypeHandleRef to resolve this problem. See the
  64  * llvm::AbstractTypeHolder class.
  65  */
  66 typedef struct LLVMOpaqueTypeHandle *LLVMTypeHandleRef;
  67
  68 typedef struct LLVMOpaqueValue *LLVMValueRef;
  69 typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
  70 typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
  71
  72 /* Used to provide a module to JIT or interpreter.
  73  * See the llvm::ModuleProvider class.
  74  */
  75 typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
  76
  77 /* Used to provide a module to JIT or interpreter.
  78  * See the llvm::MemoryBuffer class.
  79  */
  80 typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef;
  81
  82 /** See the llvm::PassManagerBase class. */
  83 typedef struct LLVMOpaquePassManager *LLVMPassManagerRef;
  84
  85 typedef enum {
  86     LLVMZExtParamAttr       = 1<<0,
  87     LLVMSExtParamAttr       = 1<<1,
  88     LLVMNoReturnParamAttr   = 1<<2,
  89     LLVMInRegParamAttr      = 1<<3,
  90     LLVMStructRetParamAttr  = 1<<4,
  91     LLVMNoUnwindParamAttr   = 1<<5,
  92     LLVMNoAliasParamAttr    = 1<<6,
  93     LLVMByValParamAttr      = 1<<7,
  94     LLVMNestParamAttr       = 1<<8,
  95     LLVMReadNoneParamAttr   = 1<<9,
  96     LLVMReadOnlyParamAttr   = 1<<10
  97 } LLVMParamAttr;
  98
  99 typedef enum {
 100   LLVMVoidTypeKind,        /**< type with no size */
 101   LLVMFloatTypeKind,       /**< 32 bit floating point type */
 102   LLVMDoubleTypeKind,      /**< 64 bit floating point type */
 103   LLVMX86_FP80TypeKind,    /**< 80 bit floating point type (X87) */
 104   LLVMFP128TypeKind,       /**< 128 bit floating point type (112-bit mantissa)*/
 105   LLVMPPC_FP128TypeKind,   /**< 128 bit floating point type (two 64-bits) */
 106   LLVMLabelTypeKind,       /**< Labels */
 107   LLVMIntegerTypeKind,     /**< Arbitrary bit width integers */
 108   LLVMFunctionTypeKind,    /**< Functions */
 109   LLVMStructTypeKind,      /**< Structures */
 110   LLVMArrayTypeKind,       /**< Arrays */
 111   LLVMPointerTypeKind,     /**< Pointers */
 112   LLVMOpaqueTypeKind,      /**< Opaque: type with unknown structure */
 113   LLVMVectorTypeKind       /**< SIMD 'packed' format, or other vector type */
 114 } LLVMTypeKind;
 115
 116 typedef enum {
 117   LLVMExternalLinkage,    /**< Externally visible function */
 118   LLVMLinkOnceLinkage,    /**< Keep one copy of function when linking (inline)*/
 119   LLVMWeakLinkage,        /**< Keep one copy of function when linking (weak) */
 120   LLVMAppendingLinkage,   /**< Special purpose, only applies to global arrays */
 121   LLVMInternalLinkage,    /**< Rename collisions when linking (static
 122                                functions) */
 123   LLVMDLLImportLinkage,   /**< Function to be imported from DLL */
 124   LLVMDLLExportLinkage,   /**< Function to be accessible from DLL */
 125   LLVMExternalWeakLinkage,/**< ExternalWeak linkage description */
 126   LLVMGhostLinkage        /**< Stand-in functions for streaming fns from
 127                                bitcode */
 128 } LLVMLinkage;
 129
 130 typedef enum {
 131   LLVMDefaultVisibility,  /**< The GV is visible */
 132   LLVMHiddenVisibility,   /**< The GV is hidden */
 133   LLVMProtectedVisibility /**< The GV is protected */
 134 } LLVMVisibility;
 135
 136 typedef enum {
 137   LLVMCCallConv           = 0,
 138   LLVMFastCallConv        = 8,
 139   LLVMColdCallConv        = 9,
 140   LLVMX86StdcallCallConv  = 64,
 141   LLVMX86FastcallCallConv = 65
 142 } LLVMCallConv;
 143
 144 typedef enum {
 145   LLVMIntEQ = 32, /**< equal */
 146   LLVMIntNE,      /**< not equal */
 147   LLVMIntUGT,     /**< unsigned greater than */
 148   LLVMIntUGE,     /**< unsigned greater or equal */
 149   LLVMIntULT,     /**< unsigned less than */
 150   LLVMIntULE,     /**< unsigned less or equal */
 151   LLVMIntSGT,     /**< signed greater than */
 152   LLVMIntSGE,     /**< signed greater or equal */
 153   LLVMIntSLT,     /**< signed less than */
 154   LLVMIntSLE      /**< signed less or equal */
 155 } LLVMIntPredicate;
 156
 157 typedef enum {
 158   LLVMRealPredicateFalse, /**< Always false (always folded) */
 159   LLVMRealOEQ,            /**< True if ordered and equal */
 160   LLVMRealOGT,            /**< True if ordered and greater than */
 161   LLVMRealOGE,            /**< True if ordered and greater than or equal */
 162   LLVMRealOLT,            /**< True if ordered and less than */
 163   LLVMRealOLE,            /**< True if ordered and less than or equal */
 164   LLVMRealONE,            /**< True if ordered and operands are unequal */
 165   LLVMRealORD,            /**< True if ordered (no nans) */
 166   LLVMRealUNO,            /**< True if unordered: isnan(X) | isnan(Y) */
 167   LLVMRealUEQ,            /**< True if unordered or equal */
 168   LLVMRealUGT,            /**< True if unordered or greater than */
 169   LLVMRealUGE,            /**< True if unordered, greater than, or equal */
 170   LLVMRealULT,            /**< True if unordered or less than */
 171   LLVMRealULE,            /**< True if unordered, less than, or equal */
 172   LLVMRealUNE,            /**< True if unordered or not equal */
 173   LLVMRealPredicateTrue   /**< Always true (always folded) */
 174 } LLVMRealPredicate;
 175
 176
 177 /*===-- Error handling ----------------------------------------------------===*/
 178
 179 void LLVMDisposeMessage(char *Message);
 180
 181
 182 /*===-- Modules -----------------------------------------------------------===*/
 183
 184 /* Create and destroy modules. */
 185 /** See llvm::Module::Module. */
 186 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
 187
 188 /** See llvm::Module::~Module. */
 189 void LLVMDisposeModule(LLVMModuleRef M);
 190
 191 /** Data layout. See Module::getDataLayout. */
 192 const char *LLVMGetDataLayout(LLVMModuleRef M);
 193 void LLVMSetDataLayout(LLVMModuleRef M, const char *Triple);
 194
 195 /** Target triple. See Module::getTargetTriple. */
 196 const char *LLVMGetTarget(LLVMModuleRef M);
 197 void LLVMSetTarget(LLVMModuleRef M, const char *Triple);
 198
 199 /** See Module::addTypeName. */
 200 int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
 201 void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
 202
 203 /** See Module::dump. */
 204 void LLVMDumpModule(LLVMModuleRef M);
 205
 206
 207 /*===-- Types -------------------------------------------------------------===*/
 208
 209 /* LLVM types conform to the following hierarchy:
 210  *
 211  *   types:
 212  *     integer type
 213  *     real type
 214  *     function type
 215  *     sequence types:
 216  *       array type
 217  *       pointer type
 218  *       vector type
 219  *     void type
 220  *     label type
 221  *     opaque type
 222  */
 223
 224 /** See llvm::LLVMTypeKind::getTypeID. */
 225 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
 226
 227 /* Operations on integer types */
 228 LLVMTypeRef LLVMInt1Type(void);
 229 LLVMTypeRef LLVMInt8Type(void);
 230 LLVMTypeRef LLVMInt16Type(void);
 231 LLVMTypeRef LLVMInt32Type(void);
 232 LLVMTypeRef LLVMInt64Type(void);
 233 LLVMTypeRef LLVMIntType(unsigned NumBits);
 234 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
 235
 236 /* Operations on real types */
 237 LLVMTypeRef LLVMFloatType(void);
 238 LLVMTypeRef LLVMDoubleType(void);
 239 LLVMTypeRef LLVMX86FP80Type(void);
 240 LLVMTypeRef LLVMFP128Type(void);
 241 LLVMTypeRef LLVMPPCFP128Type(void);
 242
 243 /* Operations on function types */
 244 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
 245                              LLVMTypeRef *ParamTypes, unsigned ParamCount,
 246                              int IsVarArg);
 247 int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
 248 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
 249 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
 250 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
 251
 252 /* Operations on struct types */
 253 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
 254                            int Packed);
 255 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
 256 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
 257 int LLVMIsPackedStruct(LLVMTypeRef StructTy);
 258
 259 /* Operations on array, pointer, and vector types (sequence types) */
 260 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
 261 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
 262 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
 263
 264 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
 265 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
 266 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
 267 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
 268
 269 /* Operations on other types */
 270 LLVMTypeRef LLVMVoidType(void);
 271 LLVMTypeRef LLVMLabelType(void);
 272 LLVMTypeRef LLVMOpaqueType(void);
 273
 274 /* Operations on type handles */
 275 LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
 276 void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
 277 LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
 278 void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
 279
 280
 281 /*===-- Values ------------------------------------------------------------===*/
 282
 283 /* The bulk of LLVM's object model consists of values, which comprise a very
 284  * rich type hierarchy.
 285  *
 286  *   values:
 287  *     constants:
 288  *       scalar constants
 289  *       composite contants
 290  *       globals:
 291  *         global variable
 292  *         function
 293  *         alias
 294  *       basic blocks
 295  */
 296
 297 /* Operations on all values */
 298 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
 299 const char *LLVMGetValueName(LLVMValueRef Val);
 300 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
 301 void LLVMDumpValue(LLVMValueRef Val);
 302
 303 /* Operations on constants of any type */
 304 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
 305 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
 306 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
 307 int LLVMIsConstant(LLVMValueRef Val);
 308 int LLVMIsNull(LLVMValueRef Val);
 309 int LLVMIsUndef(LLVMValueRef Val);
 310
 311 /* Operations on scalar constants */
 312 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
 313                           int SignExtend);
 314 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
 315 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text);
 316
 317 /* Operations on composite constants */
 318 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
 319                              int DontNullTerminate);
 320 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
 321                             LLVMValueRef *ConstantVals, unsigned Length);
 322 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
 323                              int packed);
 324 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
 325
 326 /* Constant expressions */
 327 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
 328 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
 329 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
 330 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 331 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 332 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 333 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 334 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 335 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 336 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 337 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 338 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 339 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 340 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 341 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 342 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
 343                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 344 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
 345                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 346 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 347 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 348 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 349 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
 350                           LLVMValueRef *ConstantIndices, unsigned NumIndices);
 351 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 352 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 353 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 354 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 355 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 356 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 357 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 358 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 359 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 360 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 361 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 362 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 363 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
 364                              LLVMValueRef ConstantIfTrue,
 365                              LLVMValueRef ConstantIfFalse);
 366 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
 367                                      LLVMValueRef IndexConstant);
 368 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
 369                                     LLVMValueRef ElementValueConstant,
 370                                     LLVMValueRef IndexConstant);
 371 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
 372                                     LLVMValueRef VectorBConstant,
 373                                     LLVMValueRef MaskConstant);
 374
 375 /* Operations on global variables, functions, and aliases (globals) */
 376 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
 377 int LLVMIsDeclaration(LLVMValueRef Global);
 378 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
 379 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
 380 const char *LLVMGetSection(LLVMValueRef Global);
 381 void LLVMSetSection(LLVMValueRef Global, const char *Section);
 382 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
 383 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
 384 unsigned LLVMGetAlignment(LLVMValueRef Global);
 385 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
 386
 387 /* Operations on global variables */
 388 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
 389 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
 390 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
 391 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
 392 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
 393 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
 394 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
 395 int LLVMHasInitializer(LLVMValueRef GlobalVar);
 396 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
 397 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
 398 int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
 399 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
 400 int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
 401 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
 402
 403 /* Operations on functions */
 404 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
 405                              LLVMTypeRef FunctionTy);
 406 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
 407 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
 408 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
 409 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
 410 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
 411 void LLVMDeleteFunction(LLVMValueRef Fn);
 412 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
 413 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
 414 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
 415 const char *LLVMGetCollector(LLVMValueRef Fn);
 416 void LLVMSetCollector(LLVMValueRef Fn, const char *Coll);
 417
 418 /* Operations on parameters */
 419 unsigned LLVMCountParams(LLVMValueRef Fn);
 420 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
 421 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
 422 LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
 423 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
 424 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
 425 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
 426 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
 427 void LLVMAddParamAttr(LLVMValueRef Arg, LLVMParamAttr PA);
 428 void LLVMRemoveParamAttr(LLVMValueRef Arg, LLVMParamAttr PA);
 429 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align);
 430
 431 /* Operations on basic blocks */
 432 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
 433 int LLVMValueIsBasicBlock(LLVMValueRef Val);
 434 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
 435 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
 436 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
 437 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
 438 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
 439 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
 440 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
 441 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
 442 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
 443 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
 444 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
 445                                        const char *Name);
 446 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
 447
 448 /* Operations on instructions */
 449 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
 450 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
 451 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
 452 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
 453 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
 454
 455 /* Operations on call sites */
 456 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC);
 457 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr);
 458 void LLVMAddInstrParamAttr(LLVMValueRef Instr, unsigned index, LLVMParamAttr);
 459 void LLVMRemoveInstrParamAttr(LLVMValueRef Instr, unsigned index,
 460                               LLVMParamAttr);
 461 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index,
 462                                 unsigned align);
 463
 464 /* Operations on phi nodes */
 465 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
 466                      LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
 467 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
 468 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
 469 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
 470
 471 /*===-- Instruction builders ----------------------------------------------===*/
 472
 473 /* An instruction builder represents a point within a basic block, and is the
 474  * exclusive means of building instructions using the C interface.
 475  */
 476
 477 LLVMBuilderRef LLVMCreateBuilder(void);
 478 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
 479                          LLVMValueRef Instr);
 480 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
 481 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
 482 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
 483 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
 484
 485 /* Terminators */
 486 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
 487 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
 488 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
 489 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
 490                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
 491 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
 492                              LLVMBasicBlockRef Else, unsigned NumCases);
 493 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
 494                              LLVMValueRef *Args, unsigned NumArgs,
 495                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
 496                              const char *Name);
 497 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
 498 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
 499
 500 /* Add a case to the switch instruction */
 501 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
 502                  LLVMBasicBlockRef Dest);
 503
 504 /* Arithmetic */
 505 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 506                           const char *Name);
 507 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 508                           const char *Name);
 509 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 510                           const char *Name);
 511 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 512                            const char *Name);
 513 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 514                            const char *Name);
 515 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 516                            const char *Name);
 517 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 518                            const char *Name);
 519 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 520                            const char *Name);
 521 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 522                            const char *Name);
 523 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 524                            const char *Name);
 525 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 526                            const char *Name);
 527 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 528                            const char *Name);
 529 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 530                           const char *Name);
 531 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 532                           const char *Name);
 533 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 534                           const char *Name);
 535 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 536 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 537
 538 /* Memory */
 539 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 540 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
 541                                   LLVMValueRef Val, const char *Name);
 542 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 543 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
 544                                   LLVMValueRef Val, const char *Name);
 545 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
 546 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
 547                            const char *Name);
 548 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
 549 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
 550                           LLVMValueRef *Indices, unsigned NumIndices,
 551                           const char *Name);
 552
 553 /* Casts */
 554 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
 555                             LLVMTypeRef DestTy, const char *Name);
 556 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
 557                            LLVMTypeRef DestTy, const char *Name);
 558 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
 559                            LLVMTypeRef DestTy, const char *Name);
 560 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
 561                              LLVMTypeRef DestTy, const char *Name);
 562 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
 563                              LLVMTypeRef DestTy, const char *Name);
 564 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
 565                              LLVMTypeRef DestTy, const char *Name);
 566 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
 567                              LLVMTypeRef DestTy, const char *Name);
 568 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
 569                               LLVMTypeRef DestTy, const char *Name);
 570 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
 571                             LLVMTypeRef DestTy, const char *Name);
 572 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
 573                                LLVMTypeRef DestTy, const char *Name);
 574 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
 575                                LLVMTypeRef DestTy, const char *Name);
 576 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
 577                               LLVMTypeRef DestTy, const char *Name);
 578
 579 /* Comparisons */
 580 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
 581                            LLVMValueRef LHS, LLVMValueRef RHS,
 582                            const char *Name);
 583 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
 584                            LLVMValueRef LHS, LLVMValueRef RHS,
 585                            const char *Name);
 586
 587 /* Miscellaneous instructions */
 588 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 589 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
 590                            LLVMValueRef *Args, unsigned NumArgs,
 591                            const char *Name);
 592 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
 593                              LLVMValueRef Then, LLVMValueRef Else,
 594                              const char *Name);
 595 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
 596                             const char *Name);
 597 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
 598                                      LLVMValueRef Index, const char *Name);
 599 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
 600                                     LLVMValueRef EltVal, LLVMValueRef Index,
 601                                     const char *Name);
 602 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
 603                                     LLVMValueRef V2, LLVMValueRef Mask,
 604                                     const char *Name);
 605
 606
 607 /*===-- Module providers --------------------------------------------------===*/
 608
 609 /* Encapsulates the module M in a module provider, taking ownership of the
 610  * module.
 611  * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
 612  */
 613 LLVMModuleProviderRef
 614 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
 615
 616 /* Destroys the module provider MP as well as the contained module.
 617  * See the destructor llvm::ModuleProvider::~ModuleProvider.
 618  */
 619 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP);
 620
 621
 622 /*===-- Memory buffers ----------------------------------------------------===*/
 623
 624 int LLVMCreateMemoryBufferWithContentsOfFile(const char *Path,
 625                                              LLVMMemoryBufferRef *OutMemBuf,
 626                                              char **OutMessage);
 627 int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
 628                                     char **OutMessage);
 629 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
 630
 631
 632 /*===-- Pass Managers -----------------------------------------------------===*/
 633
 634 /** Constructs a new whole-module pass pipeline. This type of pipeline is
 635     suitable for link-time optimization and whole-module transformations.
 636     See llvm::PassManager::PassManager. */
 637 LLVMPassManagerRef LLVMCreatePassManager(void);
 638
 639 /** Constructs a new function-by-function pass pipeline over the module
 640     provider. It does not take ownership of the module provider. This type of
 641     pipeline is suitable for code generation and JIT compilation tasks.
 642     See llvm::FunctionPassManager::FunctionPassManager. */
 643 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
 644
 645 /** Initializes, executes on the provided module, and finalizes all of the
 646     passes scheduled in the pass manager. Returns 1 if any of the passes
 647     modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */
 648 int LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
 649
 650 /** Initializes all of the function passes scheduled in the function pass
 651     manager. Returns 1 if any of the passes modified the module, 0 otherwise.
 652     See llvm::FunctionPassManager::doInitialization. */
 653 int LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
 654
 655 /** Executes all of the function passes scheduled in the function pass manager
 656     on the provided function. Returns 1 if any of the passes modified the
 657     function, false otherwise.
 658     See llvm::FunctionPassManager::run(Function&). */
 659 int LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
 660
 661 /** Finalizes all of the function passes scheduled in in the function pass
 662     manager. Returns 1 if any of the passes modified the module, 0 otherwise.
 663     See llvm::FunctionPassManager::doFinalization. */
 664 int LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
 665
 666 /** Frees the memory of a pass pipeline. For function pipelines, does not free
 667     the module provider.
 668     See llvm::PassManagerBase::~PassManagerBase. */
 669 void LLVMDisposePassManager(LLVMPassManagerRef PM);
 670
 671
 672 #ifdef __cplusplus
 673 }
 674
 675 namespace llvm {
 676   class ModuleProvider;
 677   class MemoryBuffer;
 678   class PassManagerBase;
 679
 680   #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)   \
 681     inline ty *unwrap(ref P) {                          \
 682       return reinterpret_cast<ty*>(P);                  \
 683     }                                                   \
 684                                                         \
 685     inline ref wrap(const ty *P) {                      \
 686       return reinterpret_cast<ref>(const_cast<ty*>(P)); \
 687     }
 688
 689   #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref)  \
 690     DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)         \
 691                                                         \
 692     template<typename T>                                \
 693     inline T *unwrap(ref P) {                           \
 694       return cast<T>(unwrap(P));                        \
 695     }
 696
 697   #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref)   \
 698     DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)         \
 699                                                         \
 700     template<typename T>                                \
 701     inline T *unwrap(ref P) {                           \
 702       T *Q = dynamic_cast<T*>(unwrap(P));               \
 703       assert(Q && "Invalid cast!");                     \
 704       return Q;                                         \
 705     }
 706
 707   DEFINE_ISA_CONVERSION_FUNCTIONS   (Type,               LLVMTypeRef          )
 708   DEFINE_ISA_CONVERSION_FUNCTIONS   (Value,              LLVMValueRef         )
 709   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module,             LLVMModuleRef        )
 710   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock,         LLVMBasicBlockRef    )
 711   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>,        LLVMBuilderRef       )
 712   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(PATypeHolder,       LLVMTypeHandleRef    )
 713   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ModuleProvider,     LLVMModuleProviderRef)
 714   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer,       LLVMMemoryBufferRef  )
 715   DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase,    LLVMPassManagerRef   )
 716
 717   #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS
 718   #undef DEFINE_ISA_CONVERSION_FUNCTIONS
 719   #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
 720
 721   /* Specialized opaque type conversions.
 722    */
 723   inline Type **unwrap(LLVMTypeRef* Tys) {
 724     return reinterpret_cast<Type**>(Tys);
 725   }
 726
 727   inline LLVMTypeRef *wrap(const Type **Tys) {
 728     return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
 729   }
 730
 731   /* Specialized opaque value conversions.
 732    */
 733   inline Value **unwrap(LLVMValueRef *Vals) {
 734     return reinterpret_cast<Value**>(Vals);
 735   }
 736
 737   template<typename T>
 738   inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
 739     #if DEBUG
 740     for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
 741       cast<T>(*I);
 742     #endif
 743     return reinterpret_cast<T**>(Vals);
 744   }
 745
 746   inline LLVMValueRef *wrap(const Value **Vals) {
 747     return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
 748   }
 749 }
 750
 751 #endif /* !defined(__cplusplus) */
 752
 753 #endif /* !defined(LLVM_C_CORE_H) */