diff options
Diffstat (limited to 'nim/llvmstat.pas')
| -rwxr-xr-x | nim/llvmstat.pas | 445 |
1 files changed, 445 insertions, 0 deletions
diff --git a/nim/llvmstat.pas b/nim/llvmstat.pas new file mode 100755 index 000000000..e7d06a284 --- /dev/null +++ b/nim/llvmstat.pas @@ -0,0 +1,445 @@ +// +// +// The Nimrod Compiler +// (c) Copyright 2008 Andreas Rumpf +// +// See the file "copying.txt", included in this +// distribution, for details about the copyright. +// +unit llvmstat; + +// this module implements the interface to LLVM. + +interface + +{$include 'config.inc'} + +uses + nsystem, ropes; + +{ Opaque types. } +{ + The top-level container for all other LLVM Intermediate Representation (IR) + objects. See the llvm::Module class. +} +type + cuint = int32; + + TLLVMTypeKind = ( + 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 + ); + + TLLVMLinkage = ( + 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 + ); + + TLLVMVisibility = ( + LLVMDefaultVisibility, // The GV is visible + LLVMHiddenVisibility, // The GV is hidden + LLVMProtectedVisibility // The GV is protected + ); + + TLLVMCallConv = ( + LLVMCCallConv = 0, + LLVMFastCallConv = 8, + LLVMColdCallConv = 9, + LLVMX86StdcallCallConv = 64, + LLVMX86FastcallCallConv = 65 + ); + + TLLVMIntPredicate = ( + 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 + ); + + TLLVMRealPredicate = ( + 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) + ); + + PLLVMBasicBlockRef = ^TLLVMBasicBlockRef; + PLLVMMemoryBufferRef = ^TLLVMMemoryBufferRef; + PLLVMTypeRef = ^TLLVMTypeRef; + PLLVMValueRef = ^TLLVMValueRef; + + TLLVMOpaqueModule = record + code: PRope; + end; + TLLVMModuleRef = ^TLLVMOpaqueModule; +{ + Each value in the LLVM IR has a type, an instance of [lltype]. See the + llvm::Type class. +} + TLLVMOpaqueType = record + kind: TLLVMTypeKind; + + end; + TLLVMTypeRef = ^TLLVMOpaqueType; +{ + When building recursive types using [refine_type], [lltype] values may become + invalid; use [lltypehandle] to resolve this problem. See the + llvm::AbstractTypeHolder] class. +} + TLLVMOpaqueTypeHandle = record end; + TLLVMTypeHandleRef = ^TLLVMOpaqueTypeHandle; + TLLVMOpaqueValue = record end; + TLLVMValueRef = ^TLLVMOpaqueValue; + TLLVMOpaqueBasicBlock = record end; + TLLVMBasicBlockRef = ^TLLVMOpaqueBasicBlock; + + TLLVMOpaqueBuilder = record end; + TLLVMBuilderRef = ^TLLVMOpaqueBuilder; +{ Used to provide a module to JIT or interpreter. + See the llvm::ModuleProvider class. +} + TLLVMOpaqueModuleProvider = record end; + TLLVMModuleProviderRef = ^TLLVMOpaqueModuleProvider; +{ Used to provide a module to JIT or interpreter. + See the llvm: : MemoryBuffer class. +} + TLLVMOpaqueMemoryBuffer = record end; + TLLVMMemoryBufferRef = ^TLLVMOpaqueMemoryBuffer; + +{===-- Error handling ----------------------------------------------------=== } +procedure LLVMDisposeMessage(msg: pchar); cdecl; +{===-- Modules -----------------------------------------------------------=== } +{ Create and destroy modules. } +function LLVMModuleCreateWithName(ModuleID: pchar): TLLVMModuleRef; cdecl; +procedure LLVMDisposeModule(M: TLLVMModuleRef);cdecl; +{ Data layout } +function LLVMGetDataLayout(M: TLLVMModuleRef): pchar;cdecl; +procedure LLVMSetDataLayout(M: TLLVMModuleRef; Triple: pchar);cdecl; +{ Target triple } +function LLVMGetTarget(M: TLLVMModuleRef): pchar;cdecl; +procedure LLVMSetTarget(M: TLLVMModuleRef; Triple: pchar);cdecl; +{ Same as Module: : addTypeName. } +function LLVMAddTypeName(M: TLLVMModuleRef; Name: pchar; Ty: TLLVMTypeRef): longint;cdecl; +procedure LLVMDeleteTypeName(M: TLLVMModuleRef; Name: pchar);cdecl; +{===-- 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 + } +function LLVMGetTypeKind(Ty: TLLVMTypeRef): TLLVMTypeKind; cdecl; +procedure LLVMRefineAbstractType(AbstractType: TLLVMTypeRef; ConcreteType: TLLVMTypeRef); cdecl; +{ Operations on integer types } +function LLVMInt1Type: TLLVMTypeRef;cdecl; +function LLVMInt8Type: TLLVMTypeRef;cdecl; +function LLVMInt16Type: TLLVMTypeRef;cdecl; +function LLVMInt32Type: TLLVMTypeRef;cdecl; +function LLVMInt64Type: TLLVMTypeRef;cdecl; +function LLVMIntType(NumBits: cuint): TLLVMTypeRef;cdecl; +function LLVMGetIntTypeWidth(IntegerTy: TLLVMTypeRef): cuint;cdecl; +{ Operations on real types } +function LLVMFloatType: TLLVMTypeRef;cdecl; +function LLVMDoubleType: TLLVMTypeRef;cdecl; +function LLVMX86FP80Type: TLLVMTypeRef;cdecl; +function LLVMFP128Type: TLLVMTypeRef;cdecl; +function LLVMPPCFP128Type: TLLVMTypeRef;cdecl; +{ Operations on function types } +function LLVMFunctionType(ReturnType: TLLVMTypeRef; ParamTypes: PLLVMTypeRef; ParamCount: cuint; IsVarArg: longint): TLLVMTypeRef;cdecl; +function LLVMIsFunctionVarArg(FunctionTy: TLLVMTypeRef): longint;cdecl; +function LLVMGetReturnType(FunctionTy: TLLVMTypeRef): TLLVMTypeRef;cdecl; +function LLVMCountParamTypes(FunctionTy: TLLVMTypeRef): cuint;cdecl; +procedure LLVMGetParamTypes(FunctionTy: TLLVMTypeRef; Dest: PLLVMTypeRef);cdecl; +{ Operations on struct types } +function LLVMStructType(ElementTypes: PLLVMTypeRef; ElementCount: cuint; isPacked: longint): TLLVMTypeRef;cdecl; +function LLVMCountStructElementTypes(StructTy: TLLVMTypeRef): cuint;cdecl; +procedure LLVMGetStructElementTypes(StructTy: TLLVMTypeRef; Dest: pLLVMTypeRef);cdecl; +function LLVMIsPackedStruct(StructTy: TLLVMTypeRef): longint;cdecl; +{ Operations on array, pointer, and vector types (sequence types) } +function LLVMArrayType(ElementType: TLLVMTypeRef; ElementCount: cuint): TLLVMTypeRef;cdecl; +function LLVMPointerType(ElementType: TLLVMTypeRef; AddressSpace: cuint): TLLVMTypeRef;cdecl; +function LLVMVectorType(ElementType: TLLVMTypeRef; ElementCount: cuint): TLLVMTypeRef;cdecl; +function LLVMGetElementType(Ty: TLLVMTypeRef): TLLVMTypeRef;cdecl; +function LLVMGetArrayLength(ArrayTy: TLLVMTypeRef): cuint;cdecl; +function LLVMGetPointerAddressSpace(PointerTy: TLLVMTypeRef): cuint;cdecl; +function LLVMGetVectorSize(VectorTy: TLLVMTypeRef): cuint;cdecl; +{ Operations on other types } +function LLVMVoidType: TLLVMTypeRef;cdecl; +function LLVMLabelType: TLLVMTypeRef;cdecl; +function LLVMOpaqueType: TLLVMTypeRef;cdecl; +{ Operations on type handles } +function LLVMCreateTypeHandle(PotentiallyAbstractTy: TLLVMTypeRef): TLLVMTypeHandleRef;cdecl; +procedure LLVMRefineType(AbstractTy: TLLVMTypeRef; ConcreteTy: TLLVMTypeRef);cdecl; +function LLVMResolveTypeHandle(TypeHandle: TLLVMTypeHandleRef): TLLVMTypeRef;cdecl; +procedure LLVMDisposeTypeHandle(TypeHandle: TLLVMTypeHandleRef);cdecl; +{===-- 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 } +function LLVMTypeOf(Val: TLLVMValueRef): TLLVMTypeRef;cdecl; +function LLVMGetValueName(Val: TLLVMValueRef): pchar;cdecl; +procedure LLVMSetValueName(Val: TLLVMValueRef; Name: pchar);cdecl; +procedure LLVMDumpValue(Val: TLLVMValueRef);cdecl; +{ Operations on constants of any type } +function LLVMConstNull(Ty: TLLVMTypeRef): TLLVMValueRef;cdecl; +{ all zeroes } +function LLVMConstAllOnes(Ty: TLLVMTypeRef): TLLVMValueRef;cdecl; +{ only for int/vector } +function LLVMGetUndef(Ty: TLLVMTypeRef): TLLVMValueRef;cdecl; +function LLVMIsConstant(Val: TLLVMValueRef): longint;cdecl; +function LLVMIsNull(Val: TLLVMValueRef): longint;cdecl; +function LLVMIsUndef(Val: TLLVMValueRef): longint;cdecl; +{ Operations on scalar constants } +function LLVMConstInt(IntTy: TLLVMTypeRef; N: qword; SignExtend: longint): TLLVMValueRef;cdecl; +function LLVMConstReal(RealTy: TLLVMTypeRef; N: double): TLLVMValueRef;cdecl; +{ Operations on composite constants } +function LLVMConstString(Str: pchar; Length: cuint; DontNullTerminate: longint): TLLVMValueRef;cdecl; +function LLVMConstArray(ArrayTy: TLLVMTypeRef; ConstantVals: pLLVMValueRef; Length: cuint): TLLVMValueRef;cdecl; +function LLVMConstStruct(ConstantVals: pLLVMValueRef; Count: cuint; ispacked: longint): TLLVMValueRef;cdecl; +function LLVMConstVector(ScalarConstantVals: pLLVMValueRef; Size: cuint): TLLVMValueRef;cdecl; +{ Constant expressions } +function LLVMSizeOf(Ty: TLLVMTypeRef): TLLVMValueRef;cdecl; +function LLVMConstNeg(ConstantVal: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstNot(ConstantVal: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstAdd(LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstSub(LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstMul(LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstUDiv(LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstSDiv(LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstFDiv(LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstURem(LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstSRem(LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstFRem(LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstAnd(LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstOr(LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstXor(LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstICmp(Predicate: TLLVMIntPredicate; LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstFCmp(Predicate: TLLVMRealPredicate; LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstShl(LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstLShr(LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstAShr(LHSConstant: TLLVMValueRef; RHSConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstGEP(ConstantVal: TLLVMValueRef; ConstantIndices: PLLVMValueRef; NumIndices: cuint): TLLVMValueRef;cdecl; +function LLVMConstTrunc(ConstantVal: TLLVMValueRef; ToType: TLLVMTypeRef): TLLVMValueRef;cdecl; +function LLVMConstSExt(ConstantVal: TLLVMValueRef; ToType: TLLVMTypeRef): TLLVMValueRef;cdecl; +function LLVMConstZExt(ConstantVal: TLLVMValueRef; ToType: TLLVMTypeRef): TLLVMValueRef;cdecl; +function LLVMConstFPTrunc(ConstantVal: TLLVMValueRef; ToType: TLLVMTypeRef): TLLVMValueRef;cdecl; +function LLVMConstFPExt(ConstantVal: TLLVMValueRef; ToType: TLLVMTypeRef): TLLVMValueRef;cdecl; +function LLVMConstUIToFP(ConstantVal: TLLVMValueRef; ToType: TLLVMTypeRef): TLLVMValueRef;cdecl; +function LLVMConstSIToFP(ConstantVal: TLLVMValueRef; ToType: TLLVMTypeRef): TLLVMValueRef;cdecl; +function LLVMConstFPToUI(ConstantVal: TLLVMValueRef; ToType: TLLVMTypeRef): TLLVMValueRef;cdecl; +function LLVMConstFPToSI(ConstantVal: TLLVMValueRef; ToType: TLLVMTypeRef): TLLVMValueRef;cdecl; +function LLVMConstPtrToInt(ConstantVal: TLLVMValueRef; ToType: TLLVMTypeRef): TLLVMValueRef;cdecl; +function LLVMConstIntToPtr(ConstantVal: TLLVMValueRef; ToType: TLLVMTypeRef): TLLVMValueRef;cdecl; +function LLVMConstBitCast(ConstantVal: TLLVMValueRef; ToType: TLLVMTypeRef): TLLVMValueRef;cdecl; +function LLVMConstSelect(ConstantCondition: TLLVMValueRef; ConstantIfTrue: TLLVMValueRef; ConstantIfFalse: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstExtractElement(VectorConstant: TLLVMValueRef; IndexConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstInsertElement(VectorConstant: TLLVMValueRef; ElementValueConstant: TLLVMValueRef; IndexConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMConstShuffleVector(VectorAConstant: TLLVMValueRef; VectorBConstant: TLLVMValueRef; MaskConstant: TLLVMValueRef): TLLVMValueRef;cdecl; +{ Operations on global variables, functions, and aliases (globals) } +function LLVMIsDeclaration(Global: TLLVMValueRef): longint;cdecl; +function LLVMGetLinkage(Global: TLLVMValueRef): TLLVMLinkage;cdecl; +procedure LLVMSetLinkage(Global: TLLVMValueRef; Linkage: TLLVMLinkage);cdecl; +function LLVMGetSection(Global: TLLVMValueRef): pchar;cdecl; +procedure LLVMSetSection(Global: TLLVMValueRef; Section: pchar);cdecl; +function LLVMGetVisibility(Global: TLLVMValueRef): TLLVMVisibility;cdecl; +procedure LLVMSetVisibility(Global: TLLVMValueRef; Viz: TLLVMVisibility);cdecl; +function LLVMGetAlignment(Global: TLLVMValueRef): cuint;cdecl; +procedure LLVMSetAlignment(Global: TLLVMValueRef; Bytes: cuint);cdecl; +{ Operations on global variables } +(* Const before type ignored *) +function LLVMAddGlobal(M: TLLVMModuleRef; Ty: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +(* Const before type ignored *) +function LLVMGetNamedGlobal(M: TLLVMModuleRef; Name: pchar): TLLVMValueRef;cdecl; +procedure LLVMDeleteGlobal(GlobalVar: TLLVMValueRef);cdecl; +function LLVMHasInitializer(GlobalVar: TLLVMValueRef): longint;cdecl; +function LLVMGetInitializer(GlobalVar: TLLVMValueRef): TLLVMValueRef;cdecl; +procedure LLVMSetInitializer(GlobalVar: TLLVMValueRef; ConstantVal: TLLVMValueRef);cdecl; +function LLVMIsThreadLocal(GlobalVar: TLLVMValueRef): longint;cdecl; +procedure LLVMSetThreadLocal(GlobalVar: TLLVMValueRef; IsThreadLocal: longint);cdecl; +function LLVMIsGlobalConstant(GlobalVar: TLLVMValueRef): longint;cdecl; +procedure LLVMSetGlobalConstant(GlobalVar: TLLVMValueRef; IsConstant: longint);cdecl; +{ Operations on functions } +(* Const before type ignored *) +function LLVMAddFunction(M: TLLVMModuleRef; Name: pchar; FunctionTy: TLLVMTypeRef): TLLVMValueRef;cdecl; +(* Const before type ignored *) +function LLVMGetNamedFunction(M: TLLVMModuleRef; Name: pchar): TLLVMValueRef;cdecl; +procedure LLVMDeleteFunction(Fn: TLLVMValueRef);cdecl; +function LLVMCountParams(Fn: TLLVMValueRef): cuint;cdecl; +procedure LLVMGetParams(Fn: TLLVMValueRef; Params: PLLVMValueRef);cdecl; +function LLVMGetParam(Fn: TLLVMValueRef; Index: cuint): TLLVMValueRef;cdecl; +function LLVMGetIntrinsicID(Fn: TLLVMValueRef): cuint;cdecl; +function LLVMGetFunctionCallConv(Fn: TLLVMValueRef): cuint;cdecl; +procedure LLVMSetFunctionCallConv(Fn: TLLVMValueRef; CC: cuint);cdecl; +(* Const before type ignored *) +function LLVMGetCollector(Fn: TLLVMValueRef): pchar;cdecl; +(* Const before type ignored *) +procedure LLVMSetCollector(Fn: TLLVMValueRef; Coll: pchar);cdecl; +{ Operations on basic blocks } +function LLVMBasicBlockAsValue(Bb: TLLVMBasicBlockRef): TLLVMValueRef;cdecl; +function LLVMValueIsBasicBlock(Val: TLLVMValueRef): longint;cdecl; +function LLVMValueAsBasicBlock(Val: TLLVMValueRef): TLLVMBasicBlockRef;cdecl; +function LLVMCountBasicBlocks(Fn: TLLVMValueRef): cuint;cdecl; +procedure LLVMGetBasicBlocks(Fn: TLLVMValueRef; BasicBlocks: PLLVMBasicBlockRef);cdecl; +function LLVMGetEntryBasicBlock(Fn: TLLVMValueRef): TLLVMBasicBlockRef;cdecl; +(* Const before type ignored *) +function LLVMAppendBasicBlock(Fn: TLLVMValueRef; Name: pchar): TLLVMBasicBlockRef;cdecl; +(* Const before type ignored *) +function LLVMInsertBasicBlock(InsertBeforeBB: TLLVMBasicBlockRef; Name: pchar): TLLVMBasicBlockRef;cdecl; +procedure LLVMDeleteBasicBlock(BB: TLLVMBasicBlockRef);cdecl; +{ Operations on call sites } +procedure LLVMSetInstructionCallConv(Instr: TLLVMValueRef; CC: cuint);cdecl; +function LLVMGetInstructionCallConv(Instr: TLLVMValueRef): cuint;cdecl; +{ Operations on phi nodes } +procedure LLVMAddIncoming(PhiNode: TLLVMValueRef; IncomingValues: PLLVMValueRef; IncomingBlocks: PLLVMBasicBlockRef; Count: cuint);cdecl; +function LLVMCountIncoming(PhiNode: TLLVMValueRef): cuint;cdecl; +function LLVMGetIncomingValue(PhiNode: TLLVMValueRef; Index: cuint): TLLVMValueRef;cdecl; +function LLVMGetIncomingBlock(PhiNode: TLLVMValueRef; Index: cuint): TLLVMBasicBlockRef;cdecl; +{===-- Instruction builders ----------------------------------------------=== } +{ An instruction builder represents a point within a basic block, and is the + * exclusive means of building instructions using the C interface. + } +function LLVMCreateBuilder: TLLVMBuilderRef;cdecl; +procedure LLVMPositionBuilderBefore(Builder: TLLVMBuilderRef; Instr: TLLVMValueRef);cdecl; +procedure LLVMPositionBuilderAtEnd(Builder: TLLVMBuilderRef; theBlock: TLLVMBasicBlockRef);cdecl; +procedure LLVMDisposeBuilder(Builder: TLLVMBuilderRef);cdecl; +{ Terminators } +function LLVMBuildRetVoid(para1: TLLVMBuilderRef): TLLVMValueRef;cdecl; +function LLVMBuildRet(para1: TLLVMBuilderRef; V: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMBuildBr(para1: TLLVMBuilderRef; Dest: TLLVMBasicBlockRef): TLLVMValueRef;cdecl; +function LLVMBuildCondBr(para1: TLLVMBuilderRef; IfCond: TLLVMValueRef; ThenBranch: TLLVMBasicBlockRef; ElseBranch: TLLVMBasicBlockRef): TLLVMValueRef;cdecl; +function LLVMBuildSwitch(para1: TLLVMBuilderRef; V: TLLVMValueRef; ElseBranch: TLLVMBasicBlockRef; NumCases: cuint): TLLVMValueRef;cdecl; +(* Const before type ignored *) +function LLVMBuildInvoke(para1: TLLVMBuilderRef; Fn: TLLVMValueRef; Args: PLLVMValueRef; NumArgs: cuint; ThenBranch: TLLVMBasicBlockRef; + Catch: TLLVMBasicBlockRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildUnwind(para1: TLLVMBuilderRef): TLLVMValueRef;cdecl; +function LLVMBuildUnreachable(para1: TLLVMBuilderRef): TLLVMValueRef;cdecl; +{ Add a case to the switch instruction } +procedure LLVMAddCase(Switch: TLLVMValueRef; OnVal: TLLVMValueRef; Dest: TLLVMBasicBlockRef);cdecl; +{ Arithmetic } +function LLVMBuildAdd(para1: TLLVMBuilderRef; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildSub(para1: TLLVMBuilderRef; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildMul(para1: TLLVMBuilderRef; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildUDiv(para1: TLLVMBuilderRef; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildSDiv(para1: TLLVMBuilderRef; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildFDiv(para1: TLLVMBuilderRef; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildURem(para1: TLLVMBuilderRef; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildSRem(para1: TLLVMBuilderRef; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildFRem(para1: TLLVMBuilderRef; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildShl(para1: TLLVMBuilderRef; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildLShr(para1: TLLVMBuilderRef; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildAShr(para1: TLLVMBuilderRef; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildAnd(para1: TLLVMBuilderRef; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildOr(para1: TLLVMBuilderRef; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildXor(para1: TLLVMBuilderRef; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildNeg(para1: TLLVMBuilderRef; V: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildNot(para1: TLLVMBuilderRef; V: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +{ Memory } +function LLVMBuildMalloc(para1: TLLVMBuilderRef; Ty: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildArrayMalloc(para1: TLLVMBuilderRef; Ty: TLLVMTypeRef; Val: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildAlloca(para1: TLLVMBuilderRef; Ty: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildArrayAlloca(para1: TLLVMBuilderRef; Ty: TLLVMTypeRef; Val: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildFree(para1: TLLVMBuilderRef; PointerVal: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMBuildLoad(para1: TLLVMBuilderRef; PointerVal: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildStore(para1: TLLVMBuilderRef; Val: TLLVMValueRef; thePtr: TLLVMValueRef): TLLVMValueRef;cdecl; +function LLVMBuildGEP(B: TLLVMBuilderRef; Pointer: TLLVMValueRef; Indices: PLLVMValueRef; NumIndices: cuint; Name: pchar): TLLVMValueRef;cdecl; +{ Casts } +function LLVMBuildTrunc(para1: TLLVMBuilderRef; Val: TLLVMValueRef; DestTy: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildZExt(para1: TLLVMBuilderRef; Val: TLLVMValueRef; DestTy: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildSExt(para1: TLLVMBuilderRef; Val: TLLVMValueRef; DestTy: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildFPToUI(para1: TLLVMBuilderRef; Val: TLLVMValueRef; DestTy: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildFPToSI(para1: TLLVMBuilderRef; Val: TLLVMValueRef; DestTy: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildUIToFP(para1: TLLVMBuilderRef; Val: TLLVMValueRef; DestTy: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildSIToFP(para1: TLLVMBuilderRef; Val: TLLVMValueRef; DestTy: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildFPTrunc(para1: TLLVMBuilderRef; Val: TLLVMValueRef; DestTy: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildFPExt(para1: TLLVMBuilderRef; Val: TLLVMValueRef; DestTy: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildPtrToInt(para1: TLLVMBuilderRef; Val: TLLVMValueRef; DestTy: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildIntToPtr(para1: TLLVMBuilderRef; Val: TLLVMValueRef; DestTy: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildBitCast(para1: TLLVMBuilderRef; Val: TLLVMValueRef; DestTy: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +{ Comparisons } +function LLVMBuildICmp(para1: TLLVMBuilderRef; Op: TLLVMIntPredicate; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildFCmp(para1: TLLVMBuilderRef; Op: TLLVMRealPredicate; LHS: TLLVMValueRef; RHS: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +{ Miscellaneous instructions } +function LLVMBuildPhi(para1: TLLVMBuilderRef; Ty: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildCall(para1: TLLVMBuilderRef; Fn: TLLVMValueRef; Args: PLLVMValueRef; NumArgs: cuint; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildSelect(para1: TLLVMBuilderRef; IfCond: TLLVMValueRef; ThenBranch: TLLVMValueRef; ElseBranch: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildVAArg(para1: TLLVMBuilderRef; List: TLLVMValueRef; Ty: TLLVMTypeRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildExtractElement(para1: TLLVMBuilderRef; VecVal: TLLVMValueRef; Index: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildInsertElement(para1: TLLVMBuilderRef; VecVal: TLLVMValueRef; EltVal: TLLVMValueRef; Index: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +function LLVMBuildShuffleVector(para1: TLLVMBuilderRef; V1: TLLVMValueRef; V2: TLLVMValueRef; Mask: TLLVMValueRef; Name: pchar): TLLVMValueRef;cdecl; +{===-- Module providers --------------------------------------------------=== } +{ Encapsulates the module M in a module provider, taking ownership of the + module. + See the constructor llvm: : ExistingModuleProvider: : ExistingModuleProvider. +} +function LLVMCreateModuleProviderForExistingModule(M: TLLVMModuleRef): TLLVMModuleProviderRef;cdecl; +{ Destroys the module provider MP as well as the contained module. + See the destructor llvm: : ModuleProvider: : ~ModuleProvider. +} +procedure LLVMDisposeModuleProvider(MP: TLLVMModuleProviderRef);cdecl; +{===-- Memory buffers ----------------------------------------------------=== } +function LLVMCreateMemoryBufferWithContentsOfFile(Path: pchar; OutMemBuf: pLLVMMemoryBufferRef; var OutMessage: pchar): longint;cdecl; +function LLVMCreateMemoryBufferWithSTDIN(OutMemBuf: pLLVMMemoryBufferRef; var OutMessage: pchar): longint;cdecl; +procedure LLVMDisposeMemoryBuffer(MemBuf: TLLVMMemoryBufferRef);cdecl; + +function LLVMWriteBitcodeToFile(M: TLLVMModuleRef; path: pchar): int; cdecl; +// Writes a module to the specified path. Returns 0 on success. + +implementation + +end. |