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 was developed by Gordon Henriksen and is distributed under the   *|
   6 |* University of Illinois Open Source 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/LLVMBuilder.h"
  42
  43 extern "C" {
  44 #endif
  45
  46
  47 /* Opaque types. */
  48 typedef struct LLVMOpaqueModule *LLVMModuleRef;
  49 typedef struct LLVMOpaqueType *LLVMTypeRef;
  50 typedef struct LLVMOpaqueTypeHandle *LLVMTypeHandleRef;
  51 typedef struct LLVMOpaqueValue *LLVMValueRef;
  52 typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
  53 typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
  54 typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
  55
  56 typedef enum {
  57   LLVMVoidTypeKind,        /* type with no size */
  58   LLVMFloatTypeKind,       /* 32 bit floating point type */
  59   LLVMDoubleTypeKind,      /* 64 bit floating point type */
  60   LLVMX86_FP80TypeKind,    /* 80 bit floating point type (X87) */
  61   LLVMFP128TypeKind,       /* 128 bit floating point type (112-bit mantissa) */
  62   LLVMPPC_FP128TypeKind,   /* 128 bit floating point type (two 64-bits) */
  63   LLVMLabelTypeKind,       /* Labels */
  64   LLVMIntegerTypeKind,     /* Arbitrary bit width integers */
  65   LLVMFunctionTypeKind,    /* Functions */
  66   LLVMStructTypeKind,      /* Structures */
  67   LLVMArrayTypeKind,       /* Arrays */
  68   LLVMPointerTypeKind,     /* Pointers */
  69   LLVMOpaqueTypeKind,      /* Opaque: type with unknown structure */
  70   LLVMVectorTypeKind       /* SIMD 'packed' format, or other vector type */
  71 } LLVMTypeKind;
  72
  73 typedef enum {
  74   LLVMExternalLinkage,    /* Externally visible function */
  75   LLVMLinkOnceLinkage,    /* Keep one copy of function when linking (inline) */
  76   LLVMWeakLinkage,        /* Keep one copy of function when linking (weak) */
  77   LLVMAppendingLinkage,   /* Special purpose, only applies to global arrays */
  78   LLVMInternalLinkage,    /* Rename collisions when linking (static functions)*/
  79   LLVMDLLImportLinkage,   /* Function to be imported from DLL */
  80   LLVMDLLExportLinkage,   /* Function to be accessible from DLL */
  81   LLVMExternalWeakLinkage,/* ExternalWeak linkage description */
  82   LLVMGhostLinkage        /* Stand-in functions for streaming fns from bitcode*/
  83 } LLVMLinkage;
  84
  85 typedef enum {
  86   LLVMDefaultVisibility,  /* The GV is visible */
  87   LLVMHiddenVisibility,   /* The GV is hidden */
  88   LLVMProtectedVisibility /* The GV is protected */
  89 } LLVMVisibility;
  90
  91 typedef enum {
  92   LLVMCCallConv           = 0,
  93   LLVMFastCallConv        = 8,
  94   LLVMColdCallConv        = 9,
  95   LLVMX86StdcallCallConv  = 64,
  96   LLVMX86FastcallCallConv = 65
  97 } LLVMCallConv;
  98
  99 typedef enum {
 100   LLVMIntEQ = 32, /* equal */
 101   LLVMIntNE,      /* not equal */
 102   LLVMIntUGT,     /* unsigned greater than */
 103   LLVMIntUGE,     /* unsigned greater or equal */
 104   LLVMIntULT,     /* unsigned less than */
 105   LLVMIntULE,     /* unsigned less or equal */
 106   LLVMIntSGT,     /* signed greater than */
 107   LLVMIntSGE,     /* signed greater or equal */
 108   LLVMIntSLT,     /* signed less than */
 109   LLVMIntSLE      /* signed less or equal */
 110 } LLVMIntPredicate;
 111
 112 typedef enum {
 113   LLVMRealPredicateFalse, /* Always false (always folded) */
 114   LLVMRealOEQ,            /* True if ordered and equal */
 115   LLVMRealOGT,            /* True if ordered and greater than */
 116   LLVMRealOGE,            /* True if ordered and greater than or equal */
 117   LLVMRealOLT,            /* True if ordered and less than */
 118   LLVMRealOLE,            /* True if ordered and less than or equal */
 119   LLVMRealONE,            /* True if ordered and operands are unequal */
 120   LLVMRealORD,            /* True if ordered (no nans) */
 121   LLVMRealUNO,            /* True if unordered: isnan(X) | isnan(Y) */
 122   LLVMRealUEQ,            /* True if unordered or equal */
 123   LLVMRealUGT,            /* True if unordered or greater than */
 124   LLVMRealUGE,            /* True if unordered, greater than, or equal */
 125   LLVMRealULT,            /* True if unordered or less than */
 126   LLVMRealULE,            /* True if unordered, less than, or equal */
 127   LLVMRealUNE,            /* True if unordered or not equal */
 128   LLVMRealPredicateTrue   /* Always true (always folded) */
 129 } LLVMRealPredicate;
 130
 131
 132 /*===-- Modules -----------------------------------------------------------===*/
 133
 134 /* Create and destroy modules. */
 135 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
 136 void LLVMDisposeModule(LLVMModuleRef M);
 137
 138 /* Same as Module::addTypeName. */
 139 int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
 140 void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
 141
 142
 143 /*===-- Types -------------------------------------------------------------===*/
 144
 145 /* LLVM types conform to the following hierarchy:
 146  *
 147  *   types:
 148  *     integer type
 149  *     real type
 150  *     function type
 151  *     sequence types:
 152  *       array type
 153  *       pointer type
 154  *       vector type
 155  *     void type
 156  *     label type
 157  *     opaque type
 158  */
 159
 160 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
 161 void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType);
 162
 163 /* Operations on integer types */
 164 LLVMTypeRef LLVMInt1Type();
 165 LLVMTypeRef LLVMInt8Type();
 166 LLVMTypeRef LLVMInt16Type();
 167 LLVMTypeRef LLVMInt32Type();
 168 LLVMTypeRef LLVMInt64Type();
 169 LLVMTypeRef LLVMIntType(unsigned NumBits);
 170 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
 171
 172 /* Operations on real types */
 173 LLVMTypeRef LLVMFloatType();
 174 LLVMTypeRef LLVMDoubleType();
 175 LLVMTypeRef LLVMX86FP80Type();
 176 LLVMTypeRef LLVMFP128Type();
 177 LLVMTypeRef LLVMPPCFP128Type();
 178
 179 /* Operations on function types */
 180 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
 181                              LLVMTypeRef *ParamTypes, unsigned ParamCount,
 182                              int IsVarArg);
 183 int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
 184 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
 185 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
 186 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
 187
 188 /* Operations on struct types */
 189 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
 190                            int Packed);
 191 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
 192 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
 193 int LLVMIsPackedStruct(LLVMTypeRef StructTy);
 194
 195 /* Operations on array, pointer, and vector types (sequence types) */
 196 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
 197 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);
 198 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
 199
 200 LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
 201 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
 202 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
 203 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
 204
 205 /* Operations on other types */
 206 LLVMTypeRef LLVMVoidType();
 207 LLVMTypeRef LLVMLabelType();
 208 LLVMTypeRef LLVMOpaqueType();
 209
 210 /* Operations on type handles */
 211 LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
 212 void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
 213 LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
 214 void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
 215
 216
 217 /*===-- Values ------------------------------------------------------------===*/
 218
 219 /* The bulk of LLVM's object model consists of values, which comprise a very
 220  * rich type hierarchy.
 221  *
 222  *   values:
 223  *     constants:
 224  *       scalar constants
 225  *       composite contants
 226  *       globals:
 227  *         global variable
 228  *         function
 229  *         alias
 230  *       basic blocks
 231  */
 232
 233 /* Operations on all values */
 234 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
 235 const char *LLVMGetValueName(LLVMValueRef Val);
 236 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
 237 void LLVMDumpValue(LLVMValueRef Val);
 238
 239 /* Operations on constants of any type */
 240 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
 241 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
 242 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
 243 int LLVMIsConstant(LLVMValueRef Val);
 244 int LLVMIsNull(LLVMValueRef Val);
 245 int LLVMIsUndef(LLVMValueRef Val);
 246
 247 /* Operations on scalar constants */
 248 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
 249                           int SignExtend);
 250 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
 251
 252 /* Operations on composite constants */
 253 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
 254                              int DontNullTerminate);
 255 LLVMValueRef LLVMConstArray(LLVMTypeRef ArrayTy,
 256                             LLVMValueRef *ConstantVals, unsigned Length);
 257 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
 258                              int packed);
 259 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
 260
 261 /* Constant expressions */
 262 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
 263 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
 264 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
 265 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 266 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 267 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 268 LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 269 LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 270 LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 271 LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 272 LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 273 LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 274 LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 275 LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 276 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 277 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
 278                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 279 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
 280                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 281 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 282 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 283 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 284 LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
 285                           LLVMValueRef *ConstantIndices, unsigned NumIndices);
 286 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 287 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 288 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 289 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 290 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 291 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 292 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 293 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 294 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 295 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 296 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 297 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
 298 LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
 299                              LLVMValueRef ConstantIfTrue,
 300                              LLVMValueRef ConstantIfFalse);
 301 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
 302                                      LLVMValueRef IndexConstant);
 303 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
 304                                     LLVMValueRef ElementValueConstant,
 305                                     LLVMValueRef IndexConstant);
 306 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
 307                                     LLVMValueRef VectorBConstant,
 308                                     LLVMValueRef MaskConstant);
 309
 310 /* Operations on global variables, functions, and aliases (globals) */
 311 int LLVMIsDeclaration(LLVMValueRef Global);
 312 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
 313 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
 314 const char *LLVMGetSection(LLVMValueRef Global);
 315 void LLVMSetSection(LLVMValueRef Global, const char *Section);
 316 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
 317 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
 318 unsigned LLVMGetAlignment(LLVMValueRef Global);
 319 void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
 320
 321 /* Operations on global variables */
 322 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
 323 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
 324 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
 325 int LLVMHasInitializer(LLVMValueRef GlobalVar);
 326 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
 327 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
 328 int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
 329 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
 330 int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
 331 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
 332
 333 /* Operations on functions */
 334 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
 335                              LLVMTypeRef FunctionTy);
 336 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
 337 void LLVMDeleteFunction(LLVMValueRef Fn);
 338 unsigned LLVMCountParams(LLVMValueRef Fn);
 339 void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
 340 LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
 341 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
 342 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
 343 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
 344 const char *LLVMGetCollector(LLVMValueRef Fn);
 345 void LLVMSetCollector(LLVMValueRef Fn, const char *Coll);
 346
 347 /* Operations on basic blocks */
 348 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb);
 349 int LLVMValueIsBasicBlock(LLVMValueRef Val);
 350 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
 351 unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
 352 void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
 353 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
 354 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
 355 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
 356                                        const char *Name);
 357 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
 358
 359 /* Operations on phi nodes */
 360 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
 361                      LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
 362 unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
 363 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
 364 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
 365
 366 /*===-- Instruction builders ----------------------------------------------===*/
 367
 368 /* An instruction builder represents a point within a basic block, and is the
 369  * exclusive means of building instructions using the C interface.
 370  */
 371
 372 LLVMBuilderRef LLVMCreateBuilder();
 373 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
 374 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
 375 void LLVMDisposeBuilder(LLVMBuilderRef Builder);
 376
 377 /* Terminators */
 378 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
 379 LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
 380 LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
 381 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
 382                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
 383 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
 384                              LLVMBasicBlockRef Else, unsigned NumCases);
 385 LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
 386                              LLVMValueRef *Args, unsigned NumArgs,
 387                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
 388                              const char *Name);
 389 LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
 390 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
 391
 392 /* Arithmetic */
 393 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 394                           const char *Name);
 395 LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 396                           const char *Name);
 397 LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 398                           const char *Name);
 399 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 400                            const char *Name);
 401 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 402                            const char *Name);
 403 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 404                            const char *Name);
 405 LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 406                            const char *Name);
 407 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 408                            const char *Name);
 409 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 410                            const char *Name);
 411 LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 412                            const char *Name);
 413 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 414                            const char *Name);
 415 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 416                            const char *Name);
 417 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 418                           const char *Name);
 419 LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 420                           const char *Name);
 421 LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
 422                           const char *Name);
 423 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 424 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 425
 426 /* Memory */
 427 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 428 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
 429                                   LLVMValueRef Val, const char *Name);
 430 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 431 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
 432                                   LLVMValueRef Val, const char *Name);
 433 LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
 434 LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
 435                            const char *Name);
 436 LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
 437 LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
 438                           LLVMValueRef *Indices, unsigned NumIndices,
 439                           const char *Name);
 440
 441 /* Casts */
 442 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
 443                             LLVMTypeRef DestTy, const char *Name);
 444 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
 445                            LLVMTypeRef DestTy, const char *Name);
 446 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
 447                            LLVMTypeRef DestTy, const char *Name);
 448 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
 449                              LLVMTypeRef DestTy, const char *Name);
 450 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
 451                              LLVMTypeRef DestTy, const char *Name);
 452 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
 453                              LLVMTypeRef DestTy, const char *Name);
 454 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
 455                              LLVMTypeRef DestTy, const char *Name);
 456 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
 457                               LLVMTypeRef DestTy, const char *Name);
 458 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
 459                             LLVMTypeRef DestTy, const char *Name);
 460 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
 461                                LLVMTypeRef DestTy, const char *Name);
 462 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
 463                                LLVMTypeRef DestTy, const char *Name);
 464 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
 465                               LLVMTypeRef DestTy, const char *Name);
 466
 467 /* Comparisons */
 468 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
 469                            LLVMValueRef LHS, LLVMValueRef RHS,
 470                            const char *Name);
 471 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
 472                            LLVMValueRef LHS, LLVMValueRef RHS,
 473                            const char *Name);
 474
 475 /* Miscellaneous instructions */
 476 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 477 LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
 478                            LLVMValueRef *Args, unsigned NumArgs,
 479                            const char *Name);
 480 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
 481                              LLVMValueRef Then, LLVMValueRef Else,
 482                              const char *Name);
 483 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
 484                             const char *Name);
 485 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
 486                                      LLVMValueRef Index, const char *Name);
 487 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
 488                                     LLVMValueRef EltVal, LLVMValueRef Index,
 489                                     const char *Name);
 490 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
 491                                     LLVMValueRef V2, LLVMValueRef Mask,
 492                                     const char *Name);
 493
 494 /*===-- Module providers --------------------------------------------------===*/
 495
 496 /* Encapsulates the module M in a module provider, taking ownership of the
 497  * module.
 498  * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
 499  */
 500 LLVMModuleProviderRef
 501 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
 502
 503 /* Destroys the module provider MP as well as the contained module.
 504  * See the destructor llvm::ModuleProvider::~ModuleProvider.
 505  */
 506 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP);
 507
 508 #ifdef __cplusplus
 509 }
 510
 511 namespace llvm {
 512   class ModuleProvider;
 513
 514   /* Opaque module conversions
 515    */
 516   inline Module *unwrap(LLVMModuleRef M) {
 517     return reinterpret_cast<Module*>(M);
 518   }
 519
 520   inline LLVMModuleRef wrap(Module *M) {
 521     return reinterpret_cast<LLVMModuleRef>(M);
 522   }
 523
 524   /* Opaque type conversions
 525    */
 526   inline Type *unwrap(LLVMTypeRef Ty) {
 527     return reinterpret_cast<Type*>(Ty);
 528   }
 529
 530   template<typename T>
 531   inline T *unwrap(LLVMTypeRef Ty) {
 532     return cast<T>(unwrap(Ty));
 533   }
 534
 535   inline Type **unwrap(LLVMTypeRef* Tys) {
 536     return reinterpret_cast<Type**>(Tys);
 537   }
 538
 539   inline LLVMTypeRef wrap(const Type *Ty) {
 540     return reinterpret_cast<LLVMTypeRef>(const_cast<Type*>(Ty));
 541   }
 542
 543   inline LLVMTypeRef *wrap(const Type **Tys) {
 544     return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
 545   }
 546
 547   /* Opaque value conversions
 548    */
 549   inline Value *unwrap(LLVMValueRef Val) {
 550     return reinterpret_cast<Value*>(Val);
 551   }
 552
 553   template<typename T>
 554   inline T *unwrap(LLVMValueRef Val) {
 555     return cast<T>(unwrap(Val));
 556   }
 557
 558   inline Value **unwrap(LLVMValueRef *Vals) {
 559     return reinterpret_cast<Value**>(Vals);
 560   }
 561
 562   template<typename T>
 563   inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
 564     #if DEBUG
 565     for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
 566       cast<T>(*I);
 567     #endif
 568     return reinterpret_cast<T**>(Vals);
 569   }
 570
 571   inline LLVMValueRef wrap(const Value *Val) {
 572     return reinterpret_cast<LLVMValueRef>(const_cast<Value*>(Val));
 573   }
 574
 575   inline LLVMValueRef *wrap(const Value **Vals) {
 576     return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
 577   }
 578
 579   /* Basic block conversions
 580    */
 581   inline BasicBlock *unwrap(LLVMBasicBlockRef BBRef) {
 582     return reinterpret_cast<BasicBlock*>(BBRef);
 583   }
 584
 585   inline LLVMBasicBlockRef wrap(const BasicBlock *BB) {
 586     return reinterpret_cast<LLVMBasicBlockRef>(const_cast<BasicBlock*>(BB));
 587   }
 588
 589   /* Opaque builder conversions.
 590    */
 591   inline LLVMBuilder *unwrap(LLVMBuilderRef B) {
 592     return reinterpret_cast<LLVMBuilder*>(B);
 593   }
 594
 595   inline LLVMBuilderRef wrap(LLVMBuilder *B) {
 596     return reinterpret_cast<LLVMBuilderRef>(B);
 597   }
 598
 599   /* Opaque type handle conversions.
 600    */
 601   inline PATypeHolder *unwrap(LLVMTypeHandleRef B) {
 602     return reinterpret_cast<PATypeHolder*>(B);
 603   }
 604
 605   inline LLVMTypeHandleRef wrap(PATypeHolder *B) {
 606     return reinterpret_cast<LLVMTypeHandleRef>(B);
 607   }
 608
 609   /* Opaque module provider conversions.
 610    */
 611   inline ModuleProvider *unwrap(LLVMModuleProviderRef P) {
 612     return reinterpret_cast<ModuleProvider*>(P);
 613   }
 614
 615   inline LLVMModuleProviderRef wrap(ModuleProvider *P) {
 616     return reinterpret_cast<LLVMModuleProviderRef>(P);
 617   }
 618 }
 619
 620 #endif /* !defined(__cplusplus) */
 621
 622 #endif /* !defined(LLVM_C_CORE_H) */