mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-07-19 03:29:22 +00:00
2618a6c112
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@42760 91177308-0d34-0410-b5e6-96231b3b80d8
593 lines
26 KiB
C
593 lines
26 KiB
C
/*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
|
|
|* *|
|
|
|* The LLVM Compiler Infrastructure *|
|
|
|* *|
|
|
|* This file was developed by Gordon Henriksen and is distributed under the *|
|
|
|* University of Illinois Open Source License. See LICENSE.TXT for details. *|
|
|
|* *|
|
|
|*===----------------------------------------------------------------------===*|
|
|
|* *|
|
|
|* This header declares the C interface to libLLVMCore.a, which implements *|
|
|
|* the LLVM intermediate representation. *|
|
|
|* *|
|
|
|* LLVM uses a polymorphic type hierarchy which C cannot represent, therefore *|
|
|
|* parameters must be passed as base types. Despite the declared types, most *|
|
|
|* of the functions provided operate only on branches of the type hierarchy. *|
|
|
|* The declared parameter names are descriptive and specify which type is *|
|
|
|* required. Additionally, each type hierarchy is documented along with the *|
|
|
|* functions that operate upon it. For more detail, refer to LLVM's C++ code. *|
|
|
|* If in doubt, refer to Core.cpp, which performs paramter downcasts in the *|
|
|
|* form unwrap<RequiredType>(Param). *|
|
|
|* *|
|
|
|* Many exotic languages can interoperate with C code but have a harder time *|
|
|
|* with C++ due to name mangling. So in addition to C, this interface enables *|
|
|
|* tools written in such languages. *|
|
|
|* *|
|
|
|* When included into a C++ source file, also declares 'wrap' and 'unwrap' *|
|
|
|* helpers to perform opaque reference<-->pointer conversions. These helpers *|
|
|
|* are shorter and more tightly typed than writing the casts by hand when *|
|
|
|* authoring bindings. In assert builds, they will do runtime type checking. *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
#ifndef LLVM_C_CORE_H
|
|
#define LLVM_C_CORE_H
|
|
|
|
#ifdef __cplusplus
|
|
|
|
/* Need these includes to support the LLVM 'cast' template for the C++ 'wrap'
|
|
and 'unwrap' conversion functions. */
|
|
#include "llvm/Module.h"
|
|
#include "llvm/Support/LLVMBuilder.h"
|
|
|
|
extern "C" {
|
|
#endif
|
|
|
|
|
|
/* Opaque types. */
|
|
typedef struct LLVMOpaqueModule *LLVMModuleRef;
|
|
typedef struct LLVMOpaqueType *LLVMTypeRef;
|
|
typedef struct LLVMOpaqueTypeHandle *LLVMTypeHandleRef;
|
|
typedef struct LLVMOpaqueValue *LLVMValueRef;
|
|
typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
|
|
typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
|
|
|
|
typedef enum {
|
|
LLVMVoidTypeKind, /* type with no size */
|
|
LLVMFloatTypeKind, /* 32 bit floating point type */
|
|
LLVMDoubleTypeKind, /* 64 bit floating point type */
|
|
LLVMX86_FP80TypeKind, /* 80 bit floating point type (X87) */
|
|
LLVMFP128TypeKind, /* 128 bit floating point type (112-bit mantissa) */
|
|
LLVMPPC_FP128TypeKind, /* 128 bit floating point type (two 64-bits) */
|
|
LLVMLabelTypeKind, /* Labels */
|
|
LLVMIntegerTypeKind, /* Arbitrary bit width integers */
|
|
LLVMFunctionTypeKind, /* Functions */
|
|
LLVMStructTypeKind, /* Structures */
|
|
LLVMArrayTypeKind, /* Arrays */
|
|
LLVMPointerTypeKind, /* Pointers */
|
|
LLVMOpaqueTypeKind, /* Opaque: type with unknown structure */
|
|
LLVMVectorTypeKind /* SIMD 'packed' format, or other vector type */
|
|
} LLVMTypeKind;
|
|
|
|
typedef enum {
|
|
LLVMExternalLinkage, /* Externally visible function */
|
|
LLVMLinkOnceLinkage, /* Keep one copy of function when linking (inline) */
|
|
LLVMWeakLinkage, /* Keep one copy of function when linking (weak) */
|
|
LLVMAppendingLinkage, /* Special purpose, only applies to global arrays */
|
|
LLVMInternalLinkage, /* Rename collisions when linking (static functions)*/
|
|
LLVMDLLImportLinkage, /* Function to be imported from DLL */
|
|
LLVMDLLExportLinkage, /* Function to be accessible from DLL */
|
|
LLVMExternalWeakLinkage,/* ExternalWeak linkage description */
|
|
LLVMGhostLinkage /* Stand-in functions for streaming fns from bitcode*/
|
|
} LLVMLinkage;
|
|
|
|
typedef enum {
|
|
LLVMDefaultVisibility, /* The GV is visible */
|
|
LLVMHiddenVisibility, /* The GV is hidden */
|
|
LLVMProtectedVisibility /* The GV is protected */
|
|
} LLVMVisibility;
|
|
|
|
typedef enum {
|
|
LLVMCCallConv = 0,
|
|
LLVMFastCallConv = 8,
|
|
LLVMColdCallConv = 9,
|
|
LLVMX86StdcallCallConv = 64,
|
|
LLVMX86FastcallCallConv = 65
|
|
} LLVMCallConv;
|
|
|
|
typedef enum {
|
|
LLVMIntEQ = 32, /* equal */
|
|
LLVMIntNE, /* not equal */
|
|
LLVMIntUGT, /* unsigned greater than */
|
|
LLVMIntUGE, /* unsigned greater or equal */
|
|
LLVMIntULT, /* unsigned less than */
|
|
LLVMIntULE, /* unsigned less or equal */
|
|
LLVMIntSGT, /* signed greater than */
|
|
LLVMIntSGE, /* signed greater or equal */
|
|
LLVMIntSLT, /* signed less than */
|
|
LLVMIntSLE /* signed less or equal */
|
|
} LLVMIntPredicate;
|
|
|
|
typedef enum {
|
|
LLVMRealPredicateFalse, /* Always false (always folded) */
|
|
LLVMRealOEQ, /* True if ordered and equal */
|
|
LLVMRealOGT, /* True if ordered and greater than */
|
|
LLVMRealOGE, /* True if ordered and greater than or equal */
|
|
LLVMRealOLT, /* True if ordered and less than */
|
|
LLVMRealOLE, /* True if ordered and less than or equal */
|
|
LLVMRealONE, /* True if ordered and operands are unequal */
|
|
LLVMRealORD, /* True if ordered (no nans) */
|
|
LLVMRealUNO, /* True if unordered: isnan(X) | isnan(Y) */
|
|
LLVMRealUEQ, /* True if unordered or equal */
|
|
LLVMRealUGT, /* True if unordered or greater than */
|
|
LLVMRealUGE, /* True if unordered, greater than, or equal */
|
|
LLVMRealULT, /* True if unordered or less than */
|
|
LLVMRealULE, /* True if unordered, less than, or equal */
|
|
LLVMRealUNE, /* True if unordered or not equal */
|
|
LLVMRealPredicateTrue /* Always true (always folded) */
|
|
} LLVMRealPredicate;
|
|
|
|
|
|
/*===-- Modules -----------------------------------------------------------===*/
|
|
|
|
/* Create and destroy modules. */
|
|
LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID);
|
|
void LLVMDisposeModule(LLVMModuleRef M);
|
|
|
|
/* Same as Module::addTypeName. */
|
|
int LLVMAddTypeName(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty);
|
|
void LLVMDeleteTypeName(LLVMModuleRef M, const char *Name);
|
|
|
|
|
|
/*===-- Types -------------------------------------------------------------===*/
|
|
|
|
/* LLVM types conform to the following hierarchy:
|
|
*
|
|
* types:
|
|
* integer type
|
|
* real type
|
|
* function type
|
|
* sequence types:
|
|
* array type
|
|
* pointer type
|
|
* vector type
|
|
* void type
|
|
* label type
|
|
* opaque type
|
|
*/
|
|
|
|
LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
|
|
void LLVMRefineAbstractType(LLVMTypeRef AbstractType, LLVMTypeRef ConcreteType);
|
|
|
|
/* Operations on integer types */
|
|
LLVMTypeRef LLVMInt1Type();
|
|
LLVMTypeRef LLVMInt8Type();
|
|
LLVMTypeRef LLVMInt16Type();
|
|
LLVMTypeRef LLVMInt32Type();
|
|
LLVMTypeRef LLVMInt64Type();
|
|
LLVMTypeRef LLVMIntType(unsigned NumBits);
|
|
unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
|
|
|
|
/* Operations on real types */
|
|
LLVMTypeRef LLVMFloatType();
|
|
LLVMTypeRef LLVMDoubleType();
|
|
LLVMTypeRef LLVMX86FP80Type();
|
|
LLVMTypeRef LLVMFP128Type();
|
|
LLVMTypeRef LLVMPPCFP128Type();
|
|
|
|
/* Operations on function types */
|
|
LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
|
|
LLVMTypeRef *ParamTypes, unsigned ParamCount,
|
|
int IsVarArg);
|
|
int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
|
|
LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
|
|
unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy);
|
|
void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
|
|
|
|
/* Operations on struct types */
|
|
LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount,
|
|
int Packed);
|
|
unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy);
|
|
void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
|
|
int LLVMIsPackedStruct(LLVMTypeRef StructTy);
|
|
|
|
/* Operations on array, pointer, and vector types (sequence types) */
|
|
LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
|
|
LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType);
|
|
LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
|
|
|
|
LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
|
|
unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
|
|
unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
|
|
|
|
/* Operations on other types */
|
|
LLVMTypeRef LLVMVoidType();
|
|
LLVMTypeRef LLVMLabelType();
|
|
LLVMTypeRef LLVMOpaqueType();
|
|
|
|
/* Operations on type handles */
|
|
LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
|
|
void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
|
|
LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
|
|
void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
|
|
|
|
|
|
/*===-- Values ------------------------------------------------------------===*/
|
|
|
|
/* The bulk of LLVM's object model consists of values, which comprise a very
|
|
* rich type hierarchy.
|
|
*
|
|
* values:
|
|
* constants:
|
|
* scalar constants
|
|
* composite contants
|
|
* globals:
|
|
* global variable
|
|
* function
|
|
* alias
|
|
* basic blocks
|
|
*/
|
|
|
|
/* Operations on all values */
|
|
LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
|
|
const char *LLVMGetValueName(LLVMValueRef Val);
|
|
void LLVMSetValueName(LLVMValueRef Val, const char *Name);
|
|
void LLVMDumpValue(LLVMValueRef Val);
|
|
|
|
/* Operations on constants of any type */
|
|
LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
|
|
LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
|
|
LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
|
|
int LLVMIsConstant(LLVMValueRef Val);
|
|
int LLVMIsNull(LLVMValueRef Val);
|
|
int LLVMIsUndef(LLVMValueRef Val);
|
|
|
|
/* Operations on scalar constants */
|
|
LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
|
|
int SignExtend);
|
|
LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
|
|
|
|
/* Operations on composite constants */
|
|
LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
|
|
int DontNullTerminate);
|
|
LLVMValueRef LLVMConstArray(LLVMTypeRef ArrayTy,
|
|
LLVMValueRef *ConstantVals, unsigned Length);
|
|
LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
|
|
int packed);
|
|
LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size);
|
|
|
|
/* Constant expressions */
|
|
LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
|
|
LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
|
|
LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
|
|
LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
|
|
LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
|
|
LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
|
|
LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
|
|
LLVMValueRef *ConstantIndices, unsigned NumIndices);
|
|
LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
|
|
LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
|
|
LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
|
|
LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
|
|
LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
|
|
LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
|
|
LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
|
|
LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
|
|
LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
|
|
LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
|
|
LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
|
|
LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
|
|
LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
|
|
LLVMValueRef ConstantIfTrue,
|
|
LLVMValueRef ConstantIfFalse);
|
|
LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
|
|
LLVMValueRef IndexConstant);
|
|
LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
|
|
LLVMValueRef ElementValueConstant,
|
|
LLVMValueRef IndexConstant);
|
|
LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
|
|
LLVMValueRef VectorBConstant,
|
|
LLVMValueRef MaskConstant);
|
|
|
|
/* Operations on global variables, functions, and aliases (globals) */
|
|
int LLVMIsDeclaration(LLVMValueRef Global);
|
|
LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
|
|
void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
|
|
const char *LLVMGetSection(LLVMValueRef Global);
|
|
void LLVMSetSection(LLVMValueRef Global, const char *Section);
|
|
LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
|
|
void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
|
|
unsigned LLVMGetAlignment(LLVMValueRef Global);
|
|
void LLVMSetAlignment(LLVMValueRef Global, unsigned Bytes);
|
|
|
|
/* Operations on global variables */
|
|
LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name);
|
|
LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
|
|
void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
|
|
int LLVMHasInitializer(LLVMValueRef GlobalVar);
|
|
LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
|
|
void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
|
|
int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
|
|
void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
|
|
int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
|
|
void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
|
|
|
|
/* Operations on functions */
|
|
LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
|
|
LLVMTypeRef FunctionTy);
|
|
LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name);
|
|
void LLVMDeleteFunction(LLVMValueRef Fn);
|
|
unsigned LLVMCountParams(LLVMValueRef Fn);
|
|
void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
|
|
LLVMValueRef LLVMGetParam(LLVMValueRef Fn, unsigned Index);
|
|
unsigned LLVMGetIntrinsicID(LLVMValueRef Fn);
|
|
unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
|
|
void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC);
|
|
|
|
/* Operations on basic blocks */
|
|
LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb);
|
|
int LLVMValueIsBasicBlock(LLVMValueRef Val);
|
|
LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
|
|
unsigned LLVMCountBasicBlocks(LLVMValueRef Fn);
|
|
void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
|
|
LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
|
|
LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, const char *Name);
|
|
LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
|
|
const char *Name);
|
|
void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
|
|
|
|
/* Operations on phi nodes */
|
|
void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
|
|
LLVMBasicBlockRef *IncomingBlocks, unsigned Count);
|
|
unsigned LLVMCountIncoming(LLVMValueRef PhiNode);
|
|
LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index);
|
|
LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index);
|
|
|
|
/*===-- Instruction builders ----------------------------------------------===*/
|
|
|
|
/* An instruction builder represents a point within a basic block, and is the
|
|
* exclusive means of building instructions using the C interface.
|
|
*/
|
|
|
|
LLVMBuilderRef LLVMCreateBuilder();
|
|
void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
|
|
void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
|
|
void LLVMDisposeBuilder(LLVMBuilderRef Builder);
|
|
|
|
/* Terminators */
|
|
LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
|
|
LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
|
|
LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
|
|
LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
|
|
LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
|
|
LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
|
|
LLVMBasicBlockRef Else, unsigned NumCases);
|
|
LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
|
|
LLVMValueRef *Args, unsigned NumArgs,
|
|
LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
|
|
LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
|
|
|
|
/* Arithmetic */
|
|
LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
|
|
LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
|
|
|
|
/* Memory */
|
|
LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
|
|
LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
|
|
LLVMValueRef Val, const char *Name);
|
|
LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
|
|
LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
|
|
LLVMValueRef Val, const char *Name);
|
|
LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
|
|
LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
|
|
LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
|
|
LLVMValueRef *Indices, unsigned NumIndices,
|
|
const char *Name);
|
|
|
|
/* Casts */
|
|
LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
|
|
LLVMTypeRef DestTy, const char *Name);
|
|
LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
|
|
LLVMTypeRef DestTy, const char *Name);
|
|
LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
|
|
LLVMTypeRef DestTy, const char *Name);
|
|
LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
|
|
LLVMTypeRef DestTy, const char *Name);
|
|
LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
|
|
LLVMTypeRef DestTy, const char *Name);
|
|
LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
|
|
LLVMTypeRef DestTy, const char *Name);
|
|
LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
|
|
LLVMTypeRef DestTy, const char *Name);
|
|
LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
|
|
LLVMTypeRef DestTy, const char *Name);
|
|
LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
|
|
LLVMTypeRef DestTy, const char *Name);
|
|
LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
|
|
LLVMTypeRef DestTy, const char *Name);
|
|
LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
|
|
LLVMTypeRef DestTy, const char *Name);
|
|
LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
|
|
LLVMTypeRef DestTy, const char *Name);
|
|
|
|
/* Comparisons */
|
|
LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
|
|
LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
|
|
LLVMValueRef LHS, LLVMValueRef RHS,
|
|
const char *Name);
|
|
|
|
/* Miscellaneous instructions */
|
|
LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
|
|
LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
|
|
LLVMValueRef *Args, unsigned NumArgs,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
|
|
LLVMValueRef Then, LLVMValueRef Else,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
|
|
LLVMValueRef Index, const char *Name);
|
|
LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
|
|
LLVMValueRef EltVal, LLVMValueRef Index,
|
|
const char *Name);
|
|
LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
|
|
LLVMValueRef V2, LLVMValueRef Mask,
|
|
const char *Name);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
|
|
namespace llvm {
|
|
/* Opaque module conversions
|
|
*/
|
|
inline Module *unwrap(LLVMModuleRef M) {
|
|
return reinterpret_cast<Module*>(M);
|
|
}
|
|
|
|
inline LLVMModuleRef wrap(Module *M) {
|
|
return reinterpret_cast<LLVMModuleRef>(M);
|
|
}
|
|
|
|
/* Opaque type conversions
|
|
*/
|
|
inline Type *unwrap(LLVMTypeRef Ty) {
|
|
return reinterpret_cast<Type*>(Ty);
|
|
}
|
|
|
|
template<typename T>
|
|
inline T *unwrap(LLVMTypeRef Ty) {
|
|
return cast<T>(unwrap(Ty));
|
|
}
|
|
|
|
inline Type **unwrap(LLVMTypeRef* Tys) {
|
|
return reinterpret_cast<Type**>(Tys);
|
|
}
|
|
|
|
inline LLVMTypeRef wrap(const Type *Ty) {
|
|
return reinterpret_cast<LLVMTypeRef>(const_cast<Type*>(Ty));
|
|
}
|
|
|
|
inline LLVMTypeRef *wrap(const Type **Tys) {
|
|
return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
|
|
}
|
|
|
|
/* Opaque value conversions
|
|
*/
|
|
inline Value *unwrap(LLVMValueRef Val) {
|
|
return reinterpret_cast<Value*>(Val);
|
|
}
|
|
|
|
template<typename T>
|
|
inline T *unwrap(LLVMValueRef Val) {
|
|
return cast<T>(unwrap(Val));
|
|
}
|
|
|
|
inline Value **unwrap(LLVMValueRef *Vals) {
|
|
return reinterpret_cast<Value**>(Vals);
|
|
}
|
|
|
|
template<typename T>
|
|
inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
|
|
#if DEBUG
|
|
for (LLVMValueRef *I = Vals, E = Vals + Length; I != E; ++I)
|
|
cast<T>(*I);
|
|
#endif
|
|
return reinterpret_cast<T**>(Vals);
|
|
}
|
|
|
|
inline LLVMValueRef wrap(const Value *Val) {
|
|
return reinterpret_cast<LLVMValueRef>(const_cast<Value*>(Val));
|
|
}
|
|
|
|
inline LLVMValueRef *wrap(const Value **Vals) {
|
|
return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
|
|
}
|
|
|
|
/* Basic block conversions
|
|
*/
|
|
inline BasicBlock *unwrap(LLVMBasicBlockRef BBRef) {
|
|
return reinterpret_cast<BasicBlock*>(BBRef);
|
|
}
|
|
|
|
inline LLVMBasicBlockRef wrap(const BasicBlock *BB) {
|
|
return reinterpret_cast<LLVMBasicBlockRef>(const_cast<BasicBlock*>(BB));
|
|
}
|
|
|
|
/* Opaque builder conversions.
|
|
*/
|
|
inline LLVMBuilder *unwrap(LLVMBuilderRef B) {
|
|
return reinterpret_cast<LLVMBuilder*>(B);
|
|
}
|
|
|
|
inline LLVMBuilderRef wrap(LLVMBuilder *B) {
|
|
return reinterpret_cast<LLVMBuilderRef>(B);
|
|
}
|
|
|
|
/* Opaque type handle conversions.
|
|
*/
|
|
inline PATypeHolder *unwrap(LLVMTypeHandleRef B) {
|
|
return reinterpret_cast<PATypeHolder*>(B);
|
|
}
|
|
|
|
inline LLVMTypeHandleRef wrap(PATypeHolder *B) {
|
|
return reinterpret_cast<LLVMTypeHandleRef>(B);
|
|
}
|
|
}
|
|
|
|
#endif /* !defined(__cplusplus) */
|
|
|
|
#endif /* !defined(LLVM_C_CORE_H) */
|