mirror of
https://github.com/nim-lang/Nim.git
synced 2026-01-02 11:12:37 +00:00
1453 lines
80 KiB
Nim
Executable File
1453 lines
80 KiB
Nim
Executable File
const
|
|
libname* = "llvm.dll" #Setup as you need
|
|
|
|
type
|
|
OpaqueContext {.pure.} = object
|
|
OpaqueModule {.pure.} = object
|
|
TOpaqueType {.pure.} = object
|
|
OpaqueTypeHandle {.pure.} = object
|
|
OpaqueValue {.pure.} = object
|
|
OpaqueBasicBlock {.pure.} = object
|
|
OpaqueBuilder {.pure.} = object
|
|
OpaqueModuleProvider {.pure.} = object
|
|
OpaqueMemoryBuffer {.pure.} = object
|
|
OpaquePassManager {.pure.} = object
|
|
OpaqueUseIterator {.pure.} = object
|
|
|
|
ContextRef* = OpaqueContext
|
|
ModuleRef* = OpaqueModule
|
|
TypeRef* = TOpaqueType
|
|
TypeHandleRef* = OpaqueTypeHandle
|
|
ValueRef* = OpaqueValue
|
|
BasicBlockRef* = OpaqueBasicBlock
|
|
BuilderRef* = OpaqueBuilder
|
|
ModuleProviderRef* = OpaqueModuleProvider
|
|
MemoryBufferRef* = OpaqueMemoryBuffer
|
|
PassManagerRef* = OpaquePassManager
|
|
UseIteratorRef* = OpaqueUseIterator
|
|
Attribute* = enum
|
|
ZExtAttribute = 1 shl 0, SExtAttribute = 1 shl 1,
|
|
NoReturnAttribute = 1 shl 2, InRegAttribute = 1 shl 3,
|
|
StructRetAttribute = 1 shl 4, NoUnwindAttribute = 1 shl 5,
|
|
NoAliasAttribute = 1 shl 6, ByValAttribute = 1 shl 7,
|
|
NestAttribute = 1 shl 8, ReadNoneAttribute = 1 shl 9,
|
|
ReadOnlyAttribute = 1 shl 10, NoInlineAttribute = 1 shl 11,
|
|
AlwaysInlineAttribute = 1 shl 12, OptimizeForSizeAttribute = 1 shl 13,
|
|
StackProtectAttribute = 1 shl 14, StackProtectReqAttribute = 1 shl 15,
|
|
NoCaptureAttribute = 1 shl 21, NoRedZoneAttribute = 1 shl 22,
|
|
NoImplicitFloatAttribute = 1 shl 23, NakedAttribute = 1 shl 24,
|
|
InlineHintAttribute = 1 shl 25
|
|
Opcode* = enum
|
|
opcRet = 1, opcBr = 2, opcSwitch = 3, opcInvoke = 4, opcUnwind = 5,
|
|
opcUnreachable = 6,
|
|
opcAdd = 7, opcFAdd = 8, opcSub = 9, opcFSub = 10, opcMul = 11,
|
|
opcFMul = 12, opcUDiv = 13,
|
|
opcSDiv = 14, opcFDiv = 15, opcURem = 16, opcSRem = 17, opcFRem = 18,
|
|
opcShl = 19,
|
|
opcLShr = 20, opcAShr = 21, opcAnd = 22, opcOr = 23, opcXor = 24,
|
|
opcMalloc = 25, opcFree = 26, opcAlloca = 27,
|
|
opcLoad = 28, opcStore = 29,
|
|
opcGetElementPtr = 30, opcTrunk = 31, opcZExt = 32, opcSExt = 33,
|
|
opcFPToUI = 34, opcFPToSI = 35, opcUIToFP = 36, opcSIToFP = 37,
|
|
opcFPTrunc = 38, opcFPExt = 39, opcPtrToInt = 40, opcIntToPtr = 41,
|
|
opcBitCast = 42, opcICmp = 43,
|
|
opcFCmp = 44, opcPHI = 45, opcCall = 46, opcSelect = 47, opcVAArg = 50,
|
|
opcExtractElement = 51, opcInsertElement = 52, opcShuffleVector = 53,
|
|
opcExtractValue = 54, opcInsertValue = 55
|
|
TypeKind* = enum
|
|
VoidTypeKind, FloatTypeKind, DoubleTypeKind, X86_FP80TypeKind,
|
|
FP128TypeKind, PPC_FP128TypeKind, LabelTypeKind, IntegerTypeKind,
|
|
FunctionTypeKind, StructTypeKind, ArrayTypeKind, PointerTypeKind,
|
|
OpaqueTypeKind, VectorTypeKind, MetadataTypeKind
|
|
TLinkage* = enum
|
|
ExternalLinkage, ## Externally visible function
|
|
AvailableExternallyLinkage, ## Keep one copy of function when linking (inline)
|
|
LinkOnceAnyLinkage, ## Same, but only replaced by something equivalent.
|
|
LinkOnceODRLinkage, ## Keep one copy of function when linking (weak)
|
|
WeakAnyLinkage, ## Same, but only replaced by something equivalent.
|
|
WeakODRLinkage, ## Special purpose, only applies to global arrays
|
|
AppendingLinkage, ## Rename collisions when linking (static functions)
|
|
InternalLinkage, ##
|
|
PrivateLinkage, ## Like Internal, but omit from symbol table
|
|
DLLImportLinkage, ## Function to be imported from DLL
|
|
DLLExportLinkage, ## Function to be accessible from DLL
|
|
ExternalWeakLinkage, ## ExternalWeak linkage description
|
|
GhostLinkage, ## Stand-in functions for streaming fns from bitcode
|
|
CommonLinkage, ## Tentative definitions
|
|
LinkerPrivateLinkage ## Like Private, but linker removes.
|
|
TVisibility* = enum
|
|
DefaultVisibility,
|
|
HiddenVisibility,
|
|
ProtectedVisibility
|
|
TCallConv* = enum
|
|
CCallConv = 0, FastCallConv = 8, ColdCallConv = 9, X86StdcallCallConv = 64,
|
|
X86FastcallCallConv = 65
|
|
IntPredicate* = enum
|
|
IntEQ = 32, IntNE, IntUGT, IntUGE, IntULT, IntULE, IntSGT, IntSGE, IntSLT,
|
|
IntSLE
|
|
RealPredicate* = enum
|
|
RealPredicateFalse, RealOEQ, RealOGT, RealOGE, RealOLT, RealOLE, RealONE,
|
|
RealORD, RealUNO, RealUEQ, RealUGT, RealUGE, RealULT, RealULE, RealUNE,
|
|
RealPredicateTrue
|
|
|
|
#===-- Error handling ----------------------------------------------------===
|
|
|
|
proc DisposeMessage*(Message: cstring){.cdecl, dynlib: libname,
|
|
importc: "LLVMDisposeMessage".}
|
|
|
|
#===-- Modules -----------------------------------------------------------===
|
|
# Create and destroy contexts.
|
|
proc ContextCreate*(): ContextRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMContextCreate".}
|
|
proc GetGlobalContext*(): ContextRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetGlobalContext".}
|
|
proc ContextDispose*(C: ContextRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMContextDispose".}
|
|
# Create and destroy modules.
|
|
# See llvm::Module::Module.
|
|
proc ModuleCreateWithName*(ModuleID: cstring): ModuleRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMModuleCreateWithName".}
|
|
proc ModuleCreateWithNameInContext*(ModuleID: cstring, C: ContextRef): ModuleRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMModuleCreateWithNameInContext".}
|
|
# See llvm::Module::~Module.
|
|
proc DisposeModule*(M: ModuleRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMDisposeModule".}
|
|
# Data layout. See Module::getDataLayout.
|
|
proc GetDataLayout*(M: ModuleRef): cstring{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetDataLayout".}
|
|
proc SetDataLayout*(M: ModuleRef, Triple: cstring){.cdecl, dynlib: libname,
|
|
importc: "LLVMSetDataLayout".}
|
|
# Target triple. See Module::getTargetTriple.
|
|
proc GetTarget*(M: ModuleRef): cstring{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetTarget".}
|
|
proc SetTarget*(M: ModuleRef, Triple: cstring){.cdecl, dynlib: libname,
|
|
importc: "LLVMSetTarget".}
|
|
# See Module::addTypeName.
|
|
proc AddTypeName*(M: ModuleRef, Name: cstring, Ty: TypeRef): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMAddTypeName".}
|
|
proc DeleteTypeName*(M: ModuleRef, Name: cstring){.cdecl, dynlib: libname,
|
|
importc: "LLVMDeleteTypeName".}
|
|
proc GetTypeByName*(M: ModuleRef, Name: cstring): TypeRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMGetTypeByName".}
|
|
# See Module::dump.
|
|
proc DumpModule*(M: ModuleRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMDumpModule".}
|
|
#===-- 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
|
|
#
|
|
# See llvm::LLVMTypeKind::getTypeID.
|
|
proc GetTypeKind*(Ty: TypeRef): TypeKind{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetTypeKind".}
|
|
# See llvm::LLVMType::getContext.
|
|
proc GetTypeContext*(Ty: TypeRef): ContextRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetTypeContext".}
|
|
# Operations on integer types
|
|
proc Int1TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMInt1TypeInContext".}
|
|
proc Int8TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMInt8TypeInContext".}
|
|
proc Int16TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMInt16TypeInContext".}
|
|
proc Int32TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMInt32TypeInContext".}
|
|
proc Int64TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMInt64TypeInContext".}
|
|
proc IntTypeInContext*(C: ContextRef, NumBits: int32): TypeRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMIntTypeInContext".}
|
|
proc Int1Type*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMInt1Type".}
|
|
proc Int8Type*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMInt8Type".}
|
|
proc Int16Type*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMInt16Type".}
|
|
proc Int32Type*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMInt32Type".}
|
|
proc Int64Type*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMInt64Type".}
|
|
proc IntType*(NumBits: int32): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIntType".}
|
|
proc GetIntTypeWidth*(IntegerTy: TypeRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetIntTypeWidth".}
|
|
# Operations on real types
|
|
proc FloatTypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMFloatTypeInContext".}
|
|
proc DoubleTypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMDoubleTypeInContext".}
|
|
proc X86FP80TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMX86FP80TypeInContext".}
|
|
proc FP128TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMFP128TypeInContext".}
|
|
proc PPCFP128TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMPPCFP128TypeInContext".}
|
|
proc FloatType*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMFloatType".}
|
|
proc DoubleType*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMDoubleType".}
|
|
proc X86FP80Type*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMX86FP80Type".}
|
|
proc FP128Type*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMFP128Type".}
|
|
proc PPCFP128Type*(): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMPPCFP128Type".}
|
|
# Operations on function types
|
|
proc FunctionType*(ReturnType: TypeRef, ParamTypes: ptr TypeRef,
|
|
ParamCount: int32, IsVarArg: int32): TypeRef {.
|
|
cdecl, dynlib: libname, importc: "LLVMFunctionType".}
|
|
proc IsFunctionVarArg*(FunctionTy: TypeRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsFunctionVarArg".}
|
|
proc GetReturnType*(FunctionTy: TypeRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetReturnType".}
|
|
proc CountParamTypes*(FunctionTy: TypeRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMCountParamTypes".}
|
|
proc GetParamTypes*(FunctionTy: TypeRef, Dest: ptr TypeRef){.cdecl,
|
|
dynlib: libname, importc: "LLVMGetParamTypes".}
|
|
# Operations on struct types
|
|
proc StructTypeInContext*(C: ContextRef, ElementTypes: ptr TypeRef,
|
|
ElementCount: int32, isPacked: int32): TypeRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMStructTypeInContext".}
|
|
proc StructType*(ElementTypes: ptr TypeRef, ElementCount: int32, isPacked: int32): TypeRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMStructType".}
|
|
proc CountStructElementTypes*(StructTy: TypeRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMCountStructElementTypes".}
|
|
proc GetStructElementTypes*(StructTy: TypeRef, Dest: ptr TypeRef){.cdecl,
|
|
dynlib: libname, importc: "LLVMGetStructElementTypes".}
|
|
proc IsPackedStruct*(StructTy: TypeRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsPackedStruct".}
|
|
# Operations on array, pointer, and vector types (sequence types)
|
|
proc ArrayType*(ElementType: TypeRef, ElementCount: int32): TypeRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMArrayType".}
|
|
proc PointerType*(ElementType: TypeRef, AddressSpace: int32): TypeRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMPointerType".}
|
|
proc VectorType*(ElementType: TypeRef, ElementCount: int32): TypeRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMVectorType".}
|
|
proc GetElementType*(Ty: TypeRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetElementType".}
|
|
proc GetArrayLength*(ArrayTy: TypeRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetArrayLength".}
|
|
proc GetPointerAddressSpace*(PointerTy: TypeRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetPointerAddressSpace".}
|
|
proc GetVectorSize*(VectorTy: TypeRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetVectorSize".}
|
|
# Operations on other types
|
|
proc VoidTypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMVoidTypeInContext".}
|
|
proc LabelTypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMLabelTypeInContext".}
|
|
proc OpaqueTypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMOpaqueTypeInContext".}
|
|
proc VoidType*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMVoidType".}
|
|
proc LabelType*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMLabelType".}
|
|
proc OpaqueType*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMOpaqueType".}
|
|
# Operations on type handles
|
|
proc CreateTypeHandle*(PotentiallyAbstractTy: TypeRef): TypeHandleRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMCreateTypeHandle".}
|
|
proc RefineType*(AbstractTy: TypeRef, ConcreteTy: TypeRef){.cdecl,
|
|
dynlib: libname, importc: "LLVMRefineType".}
|
|
proc ResolveTypeHandle*(TypeHandle: TypeHandleRef): TypeRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMResolveTypeHandle".}
|
|
proc DisposeTypeHandle*(TypeHandle: TypeHandleRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMDisposeTypeHandle".}
|
|
# Operations on all values
|
|
proc TypeOf*(Val: ValueRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMTypeOf".}
|
|
proc GetValueName*(Val: ValueRef): cstring{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetValueName".}
|
|
proc SetValueName*(Val: ValueRef, Name: cstring){.cdecl, dynlib: libname,
|
|
importc: "LLVMSetValueName".}
|
|
proc DumpValue*(Val: ValueRef){.cdecl, dynlib: libname, importc: "LLVMDumpValue".}
|
|
proc ReplaceAllUsesWith*(OldVal: ValueRef, NewVal: ValueRef){.cdecl,
|
|
dynlib: libname, importc: "LLVMReplaceAllUsesWith".}
|
|
# Conversion functions. Return the input value if it is an instance of the
|
|
# specified class, otherwise NULL. See llvm::dyn_cast_or_null<>.
|
|
proc IsAArgument*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAArgument".}
|
|
proc IsABasicBlock*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsABasicBlock".}
|
|
proc IsAInlineAsm*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAInlineAsm".}
|
|
proc IsAUser*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAUser".}
|
|
proc IsAConstant*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAConstant".}
|
|
proc IsAConstantAggregateZero*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAConstantAggregateZero".}
|
|
proc IsAConstantArray*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAConstantArray".}
|
|
proc IsAConstantExpr*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAConstantExpr".}
|
|
proc IsAConstantFP*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAConstantFP".}
|
|
proc IsAConstantInt*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAConstantInt".}
|
|
proc IsAConstantPointerNull*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAConstantPointerNull".}
|
|
proc IsAConstantStruct*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAConstantStruct".}
|
|
proc IsAConstantVector*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAConstantVector".}
|
|
proc IsAGlobalValue*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAGlobalValue".}
|
|
proc IsAFunction*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAFunction".}
|
|
proc IsAGlobalAlias*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAGlobalAlias".}
|
|
proc IsAGlobalVariable*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAGlobalVariable".}
|
|
proc IsAUndefValue*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAUndefValue".}
|
|
proc IsAInstruction*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAInstruction".}
|
|
proc IsABinaryOperator*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsABinaryOperator".}
|
|
proc IsACallInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsACallInst".}
|
|
proc IsAIntrinsicInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAIntrinsicInst".}
|
|
proc IsADbgInfoIntrinsic*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsADbgInfoIntrinsic".}
|
|
proc IsADbgDeclareInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsADbgDeclareInst".}
|
|
proc IsADbgFuncStartInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsADbgFuncStartInst".}
|
|
proc IsADbgRegionEndInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsADbgRegionEndInst".}
|
|
proc IsADbgRegionStartInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsADbgRegionStartInst".}
|
|
proc IsADbgStopPointInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsADbgStopPointInst".}
|
|
proc IsAEHSelectorInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAEHSelectorInst".}
|
|
proc IsAMemIntrinsic*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAMemIntrinsic".}
|
|
proc IsAMemCpyInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAMemCpyInst".}
|
|
proc IsAMemMoveInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAMemMoveInst".}
|
|
proc IsAMemSetInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAMemSetInst".}
|
|
proc IsACmpInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsACmpInst".}
|
|
proc IsAFCmpInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAFCmpInst".}
|
|
proc IsAICmpInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAICmpInst".}
|
|
proc IsAExtractElementInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAExtractElementInst".}
|
|
proc IsAGetElementPtrInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAGetElementPtrInst".}
|
|
proc IsAInsertElementInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAInsertElementInst".}
|
|
proc IsAInsertValueInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAInsertValueInst".}
|
|
proc IsAPHINode*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAPHINode".}
|
|
proc IsASelectInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsASelectInst".}
|
|
proc IsAShuffleVectorInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAShuffleVectorInst".}
|
|
proc IsAStoreInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAStoreInst".}
|
|
proc IsATerminatorInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsATerminatorInst".}
|
|
proc IsABranchInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsABranchInst".}
|
|
proc IsAInvokeInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAInvokeInst".}
|
|
proc IsAReturnInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAReturnInst".}
|
|
proc IsASwitchInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsASwitchInst".}
|
|
proc IsAUnreachableInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAUnreachableInst".}
|
|
proc IsAUnwindInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAUnwindInst".}
|
|
proc IsAUnaryInstruction*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAUnaryInstruction".}
|
|
proc IsAAllocationInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAAllocationInst".}
|
|
proc IsAAllocaInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAAllocaInst".}
|
|
proc IsACastInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsACastInst".}
|
|
proc IsABitCastInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsABitCastInst".}
|
|
proc IsAFPExtInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAFPExtInst".}
|
|
proc IsAFPToSIInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAFPToSIInst".}
|
|
proc IsAFPToUIInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAFPToUIInst".}
|
|
proc IsAFPTruncInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAFPTruncInst".}
|
|
proc IsAIntToPtrInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAIntToPtrInst".}
|
|
proc IsAPtrToIntInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAPtrToIntInst".}
|
|
proc IsASExtInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsASExtInst".}
|
|
proc IsASIToFPInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsASIToFPInst".}
|
|
proc IsATruncInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsATruncInst".}
|
|
proc IsAUIToFPInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAUIToFPInst".}
|
|
proc IsAZExtInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAZExtInst".}
|
|
proc IsAExtractValueInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAExtractValueInst".}
|
|
proc IsAFreeInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAFreeInst".}
|
|
proc IsALoadInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsALoadInst".}
|
|
proc IsAVAArgInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsAVAArgInst".}
|
|
# Operations on Uses
|
|
proc GetFirstUse*(Val: ValueRef): UseIteratorRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetFirstUse".}
|
|
proc GetNextUse*(U: UseIteratorRef): UseIteratorRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetNextUse".}
|
|
proc GetUser*(U: UseIteratorRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetUser".}
|
|
proc GetUsedValue*(U: UseIteratorRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetUsedValue".}
|
|
# Operations on Users
|
|
proc GetOperand*(Val: ValueRef, Index: int32): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetOperand".}
|
|
# Operations on constants of any type
|
|
proc ConstNull*(Ty: TypeRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMConstNull".}
|
|
# all zeroes
|
|
proc ConstAllOnes*(Ty: TypeRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMConstAllOnes".}
|
|
# only for int/vector
|
|
proc GetUndef*(Ty: TypeRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetUndef".}
|
|
proc IsConstant*(Val: ValueRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsConstant".}
|
|
proc IsNull*(Val: ValueRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsNull".}
|
|
proc IsUndef*(Val: ValueRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsUndef".}
|
|
proc ConstPointerNull*(Ty: TypeRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMConstPointerNull".}
|
|
# Operations on scalar constants
|
|
proc ConstInt*(IntTy: TypeRef, N: int64, SignExtend: int32): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstInt".}
|
|
proc ConstIntOfString*(IntTy: TypeRef, Text: cstring, Radix: byte): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMConstIntOfString".}
|
|
proc ConstIntOfStringAndSize*(IntTy: TypeRef, Text: cstring, SLen: int32,
|
|
Radix: byte): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMConstIntOfStringAndSize".}
|
|
proc ConstReal*(RealTy: TypeRef, N: float64): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMConstReal".}
|
|
proc ConstRealOfString*(RealTy: TypeRef, Text: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstRealOfString".}
|
|
proc ConstRealOfStringAndSize*(RealTy: TypeRef, Text: cstring, SLen: int32): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMConstRealOfStringAndSize".}
|
|
proc ConstIntGetZExtValue*(ConstantVal: ValueRef): int64{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstIntGetZExtValue".}
|
|
proc ConstIntGetSExtValue*(ConstantVal: ValueRef): int64{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstIntGetSExtValue".}
|
|
# Operations on composite constants
|
|
proc ConstStringInContext*(C: ContextRef, Str: cstring, len: int32,
|
|
DontNullTerminate: int32): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstStringInContext".}
|
|
proc ConstStructInContext*(C: ContextRef, ConstantVals: ptr ValueRef,
|
|
Count: int32,
|
|
isPacked: int32): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMConstStructInContext".}
|
|
proc ConstString*(Str: cstring, len: int32, DontNullTerminate: int32): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMConstString".}
|
|
proc ConstArray*(ElementTy: TypeRef, ConstantVals: ptr ValueRef, len: int32): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMConstArray".}
|
|
proc ConstStruct*(ConstantVals: ptr ValueRef, Count: int32, isPacked: int32): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMConstStruct".}
|
|
proc ConstVector*(ScalarConstantVals: ptr ValueRef, Size: int32): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstVector".}
|
|
# Constant expressions
|
|
proc GetConstOpcode*(ConstantVal: ValueRef): Opcode{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetConstOpcode".}
|
|
proc AlignOf*(Ty: TypeRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMAlignOf".}
|
|
proc SizeOf*(Ty: TypeRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMSizeOf".}
|
|
proc ConstNeg*(ConstantVal: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMConstNeg".}
|
|
proc ConstFNeg*(ConstantVal: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMConstFNeg".}
|
|
proc ConstNot*(ConstantVal: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMConstNot".}
|
|
proc ConstAdd*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstAdd".}
|
|
proc ConstNSWAdd*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMConstNSWAdd".}
|
|
proc ConstFAdd*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstFAdd".}
|
|
proc ConstSub*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstSub".}
|
|
proc ConstFSub*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstFSub".}
|
|
proc ConstMul*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstMul".}
|
|
proc ConstFMul*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstFMul".}
|
|
proc ConstUDiv*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstUDiv".}
|
|
proc ConstSDiv*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstSDiv".}
|
|
proc ConstExactSDiv*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMConstExactSDiv".}
|
|
proc ConstFDiv*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstFDiv".}
|
|
proc ConstURem*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstURem".}
|
|
proc ConstSRem*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstSRem".}
|
|
proc ConstFRem*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstFRem".}
|
|
proc ConstAnd*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstAnd".}
|
|
proc ConstOr*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstOr".}
|
|
proc ConstXor*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstXor".}
|
|
proc ConstICmp*(Predicate: IntPredicate, LHSConstant: ValueRef,
|
|
RHSConstant: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMConstICmp".}
|
|
proc ConstFCmp*(Predicate: RealPredicate, LHSConstant: ValueRef,
|
|
RHSConstant: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMConstFCmp".}
|
|
proc ConstShl*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstShl".}
|
|
proc ConstLShr*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstLShr".}
|
|
proc ConstAShr*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstAShr".}
|
|
proc ConstGEP*(ConstantVal: ValueRef, ConstantIndices: ptr ValueRef,
|
|
NumIndices: int32): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMConstGEP".}
|
|
proc ConstInBoundsGEP*(ConstantVal: ValueRef, ConstantIndices: ptr ValueRef,
|
|
NumIndices: int32): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMConstInBoundsGEP".}
|
|
proc ConstTrunc*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstTrunc".}
|
|
proc ConstSExt*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstSExt".}
|
|
proc ConstZExt*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstZExt".}
|
|
proc ConstFPTrunc*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstFPTrunc".}
|
|
proc ConstFPExt*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstFPExt".}
|
|
proc ConstUIToFP*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstUIToFP".}
|
|
proc ConstSIToFP*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstSIToFP".}
|
|
proc ConstFPToUI*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstFPToUI".}
|
|
proc ConstFPToSI*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstFPToSI".}
|
|
proc ConstPtrToInt*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstPtrToInt".}
|
|
proc ConstIntToPtr*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstIntToPtr".}
|
|
proc ConstBitCast*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstBitCast".}
|
|
proc ConstZExtOrBitCast*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMConstZExtOrBitCast".}
|
|
proc ConstSExtOrBitCast*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMConstSExtOrBitCast".}
|
|
proc ConstTruncOrBitCast*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMConstTruncOrBitCast".}
|
|
proc ConstPointerCast*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstPointerCast".}
|
|
proc ConstIntCast*(ConstantVal: ValueRef, ToType: TypeRef, isSigned: int32): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMConstIntCast".}
|
|
proc ConstFPCast*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstFPCast".}
|
|
proc ConstSelect*(ConstantCondition: ValueRef, ConstantIfTrue: ValueRef,
|
|
ConstantIfFalse: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMConstSelect".}
|
|
proc ConstExtractElement*(VectorConstant: ValueRef, IndexConstant: ValueRef): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMConstExtractElement".}
|
|
proc ConstInsertElement*(VectorConstant: ValueRef,
|
|
ElementValueConstant: ValueRef, IndexConstant: ValueRef): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMConstInsertElement".}
|
|
proc ConstShuffleVector*(VectorAConstant: ValueRef, VectorBConstant: ValueRef,
|
|
MaskConstant: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstShuffleVector".}
|
|
proc ConstExtractValue*(AggConstant: ValueRef, IdxList: ptr int32, NumIdx: int32): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMConstExtractValue".}
|
|
proc ConstInsertValue*(AggConstant: ValueRef, ElementValueConstant: ValueRef,
|
|
IdxList: ptr int32, NumIdx: int32): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMConstInsertValue".}
|
|
proc ConstInlineAsm*(Ty: TypeRef, AsmString: cstring, Constraints: cstring,
|
|
HasSideEffects: int32): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMConstInlineAsm".}
|
|
# Operations on global variables, functions, and aliases (globals)
|
|
proc GetGlobalParent*(Global: ValueRef): ModuleRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetGlobalParent".}
|
|
proc IsDeclaration*(Global: ValueRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsDeclaration".}
|
|
proc GetLinkage*(Global: ValueRef): TLinkage{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetLinkage".}
|
|
proc SetLinkage*(Global: ValueRef, Linkage: TLinkage){.cdecl, dynlib: libname,
|
|
importc: "LLVMSetLinkage".}
|
|
proc GetSection*(Global: ValueRef): cstring{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetSection".}
|
|
proc SetSection*(Global: ValueRef, Section: cstring){.cdecl, dynlib: libname,
|
|
importc: "LLVMSetSection".}
|
|
proc GetVisibility*(Global: ValueRef): TVisibility{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetVisibility".}
|
|
proc SetVisibility*(Global: ValueRef, Viz: TVisibility){.cdecl, dynlib: libname,
|
|
importc: "LLVMSetVisibility".}
|
|
proc GetAlignment*(Global: ValueRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetAlignment".}
|
|
proc SetAlignment*(Global: ValueRef, Bytes: int32){.cdecl, dynlib: libname,
|
|
importc: "LLVMSetAlignment".}
|
|
# Operations on global variables
|
|
proc AddGlobal*(M: ModuleRef, Ty: TypeRef, Name: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMAddGlobal".}
|
|
proc GetNamedGlobal*(M: ModuleRef, Name: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMGetNamedGlobal".}
|
|
proc GetFirstGlobal*(M: ModuleRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetFirstGlobal".}
|
|
proc GetLastGlobal*(M: ModuleRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetLastGlobal".}
|
|
proc GetNextGlobal*(GlobalVar: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetNextGlobal".}
|
|
proc GetPreviousGlobal*(GlobalVar: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetPreviousGlobal".}
|
|
proc DeleteGlobal*(GlobalVar: ValueRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMDeleteGlobal".}
|
|
proc GetInitializer*(GlobalVar: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetInitializer".}
|
|
proc SetInitializer*(GlobalVar: ValueRef, ConstantVal: ValueRef){.cdecl,
|
|
dynlib: libname, importc: "LLVMSetInitializer".}
|
|
proc IsThreadLocal*(GlobalVar: ValueRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsThreadLocal".}
|
|
proc SetThreadLocal*(GlobalVar: ValueRef, IsThreadLocal: int32){.cdecl,
|
|
dynlib: libname, importc: "LLVMSetThreadLocal".}
|
|
proc IsGlobalConstant*(GlobalVar: ValueRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsGlobalConstant".}
|
|
proc SetGlobalConstant*(GlobalVar: ValueRef, IsConstant: int32){.cdecl,
|
|
dynlib: libname, importc: "LLVMSetGlobalConstant".}
|
|
# Operations on aliases
|
|
proc AddAlias*(M: ModuleRef, Ty: TypeRef, Aliasee: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMAddAlias".}
|
|
# Operations on functions
|
|
proc AddFunction*(M: ModuleRef, Name: cstring, FunctionTy: TypeRef): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMAddFunction".}
|
|
proc GetNamedFunction*(M: ModuleRef, Name: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMGetNamedFunction".}
|
|
proc GetFirstFunction*(M: ModuleRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetFirstFunction".}
|
|
proc GetLastFunction*(M: ModuleRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetLastFunction".}
|
|
proc GetNextFunction*(Fn: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetNextFunction".}
|
|
proc GetPreviousFunction*(Fn: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetPreviousFunction".}
|
|
proc DeleteFunction*(Fn: ValueRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMDeleteFunction".}
|
|
proc GetIntrinsicID*(Fn: ValueRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetIntrinsicID".}
|
|
proc GetFunctionCallConv*(Fn: ValueRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetFunctionCallConv".}
|
|
proc SetFunctionCallConv*(Fn: ValueRef, CC: int32){.cdecl, dynlib: libname,
|
|
importc: "LLVMSetFunctionCallConv".}
|
|
proc GetGC*(Fn: ValueRef): cstring{.cdecl, dynlib: libname, importc: "LLVMGetGC".}
|
|
proc SetGC*(Fn: ValueRef, Name: cstring){.cdecl, dynlib: libname,
|
|
importc: "LLVMSetGC".}
|
|
proc AddFunctionAttr*(Fn: ValueRef, PA: Attribute){.cdecl, dynlib: libname,
|
|
importc: "LLVMAddFunctionAttr".}
|
|
proc GetFunctionAttr*(Fn: ValueRef): Attribute{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetFunctionAttr".}
|
|
proc RemoveFunctionAttr*(Fn: ValueRef, PA: Attribute){.cdecl, dynlib: libname,
|
|
importc: "LLVMRemoveFunctionAttr".}
|
|
# Operations on parameters
|
|
proc CountParams*(Fn: ValueRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMCountParams".}
|
|
proc GetParams*(Fn: ValueRef, Params: ptr ValueRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMGetParams".}
|
|
proc GetParam*(Fn: ValueRef, Index: int32): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetParam".}
|
|
proc GetParamParent*(Inst: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetParamParent".}
|
|
proc GetFirstParam*(Fn: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetFirstParam".}
|
|
proc GetLastParam*(Fn: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetLastParam".}
|
|
proc GetNextParam*(Arg: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetNextParam".}
|
|
proc GetPreviousParam*(Arg: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetPreviousParam".}
|
|
proc AddAttribute*(Arg: ValueRef, PA: Attribute){.cdecl, dynlib: libname,
|
|
importc: "LLVMAddAttribute".}
|
|
proc RemoveAttribute*(Arg: ValueRef, PA: Attribute){.cdecl, dynlib: libname,
|
|
importc: "LLVMRemoveAttribute".}
|
|
proc GetAttribute*(Arg: ValueRef): Attribute{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetAttribute".}
|
|
proc SetParamAlignment*(Arg: ValueRef, align: int32){.cdecl, dynlib: libname,
|
|
importc: "LLVMSetParamAlignment".}
|
|
# Operations on basic blocks
|
|
proc BasicBlockAsValue*(BB: BasicBlockRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBasicBlockAsValue".}
|
|
proc ValueIsBasicBlock*(Val: ValueRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMValueIsBasicBlock".}
|
|
proc ValueAsBasicBlock*(Val: ValueRef): BasicBlockRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMValueAsBasicBlock".}
|
|
proc GetBasicBlockParent*(BB: BasicBlockRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetBasicBlockParent".}
|
|
proc CountBasicBlocks*(Fn: ValueRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMCountBasicBlocks".}
|
|
proc GetBasicBlocks*(Fn: ValueRef, BasicBlocks: ptr BasicBlockRef){.cdecl,
|
|
dynlib: libname, importc: "LLVMGetBasicBlocks".}
|
|
proc GetFirstBasicBlock*(Fn: ValueRef): BasicBlockRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetFirstBasicBlock".}
|
|
proc GetLastBasicBlock*(Fn: ValueRef): BasicBlockRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetLastBasicBlock".}
|
|
proc GetNextBasicBlock*(BB: BasicBlockRef): BasicBlockRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMGetNextBasicBlock".}
|
|
proc GetPreviousBasicBlock*(BB: BasicBlockRef): BasicBlockRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMGetPreviousBasicBlock".}
|
|
proc GetEntryBasicBlock*(Fn: ValueRef): BasicBlockRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetEntryBasicBlock".}
|
|
proc AppendBasicBlockInContext*(C: ContextRef, Fn: ValueRef, Name: cstring): BasicBlockRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMAppendBasicBlockInContext".}
|
|
proc InsertBasicBlockInContext*(C: ContextRef, BB: BasicBlockRef, Name: cstring): BasicBlockRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMInsertBasicBlockInContext".}
|
|
proc AppendBasicBlock*(Fn: ValueRef, Name: cstring): BasicBlockRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMAppendBasicBlock".}
|
|
proc InsertBasicBlock*(InsertBeforeBB: BasicBlockRef, Name: cstring): BasicBlockRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMInsertBasicBlock".}
|
|
proc DeleteBasicBlock*(BB: BasicBlockRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMDeleteBasicBlock".}
|
|
# Operations on instructions
|
|
proc GetInstructionParent*(Inst: ValueRef): BasicBlockRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMGetInstructionParent".}
|
|
proc GetFirstInstruction*(BB: BasicBlockRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetFirstInstruction".}
|
|
proc GetLastInstruction*(BB: BasicBlockRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetLastInstruction".}
|
|
proc GetNextInstruction*(Inst: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetNextInstruction".}
|
|
proc GetPreviousInstruction*(Inst: ValueRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetPreviousInstruction".}
|
|
# Operations on call sites
|
|
proc SetInstructionCallConv*(Instr: ValueRef, CC: int32){.cdecl,
|
|
dynlib: libname, importc: "LLVMSetInstructionCallConv".}
|
|
proc GetInstructionCallConv*(Instr: ValueRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMGetInstructionCallConv".}
|
|
proc AddInstrAttribute*(Instr: ValueRef, index: int32, para3: Attribute){.cdecl,
|
|
dynlib: libname, importc: "LLVMAddInstrAttribute".}
|
|
proc RemoveInstrAttribute*(Instr: ValueRef, index: int32, para3: Attribute){.
|
|
cdecl, dynlib: libname, importc: "LLVMRemoveInstrAttribute".}
|
|
proc SetInstrParamAlignment*(Instr: ValueRef, index: int32, align: int32){.
|
|
cdecl, dynlib: libname, importc: "LLVMSetInstrParamAlignment".}
|
|
# Operations on call instructions (only)
|
|
proc IsTailCall*(CallInst: ValueRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMIsTailCall".}
|
|
proc SetTailCall*(CallInst: ValueRef, IsTailCall: int32){.cdecl,
|
|
dynlib: libname, importc: "LLVMSetTailCall".}
|
|
# Operations on phi nodes
|
|
proc AddIncoming*(PhiNode: ValueRef, IncomingValues: ptr ValueRef,
|
|
IncomingBlocks: ptr BasicBlockRef, Count: int32){.cdecl,
|
|
dynlib: libname, importc: "LLVMAddIncoming".}
|
|
proc CountIncoming*(PhiNode: ValueRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMCountIncoming".}
|
|
proc GetIncomingValue*(PhiNode: ValueRef, Index: int32): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMGetIncomingValue".}
|
|
proc GetIncomingBlock*(PhiNode: ValueRef, Index: int32): BasicBlockRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMGetIncomingBlock".}
|
|
#===-- Instruction builders ----------------------------------------------===
|
|
# An instruction builder represents a point within a basic block, and is the
|
|
# * exclusive means of building instructions using the C interface.
|
|
#
|
|
proc CreateBuilderInContext*(C: ContextRef): BuilderRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMCreateBuilderInContext".}
|
|
proc CreateBuilder*(): BuilderRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMCreateBuilder".}
|
|
proc PositionBuilder*(Builder: BuilderRef, theBlock: BasicBlockRef,
|
|
Instr: ValueRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMPositionBuilder".}
|
|
proc PositionBuilderBefore*(Builder: BuilderRef, Instr: ValueRef){.cdecl,
|
|
dynlib: libname, importc: "LLVMPositionBuilderBefore".}
|
|
proc PositionBuilderAtEnd*(Builder: BuilderRef, theBlock: BasicBlockRef){.cdecl,
|
|
dynlib: libname, importc: "LLVMPositionBuilderAtEnd".}
|
|
proc GetInsertBlock*(Builder: BuilderRef): BasicBlockRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMGetInsertBlock".}
|
|
proc ClearInsertionPosition*(Builder: BuilderRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMClearInsertionPosition".}
|
|
proc InsertIntoBuilder*(Builder: BuilderRef, Instr: ValueRef){.cdecl,
|
|
dynlib: libname, importc: "LLVMInsertIntoBuilder".}
|
|
proc InsertIntoBuilderWithName*(Builder: BuilderRef, Instr: ValueRef,
|
|
Name: cstring){.cdecl, dynlib: libname,
|
|
importc: "LLVMInsertIntoBuilderWithName".}
|
|
proc DisposeBuilder*(Builder: BuilderRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMDisposeBuilder".}
|
|
# Terminators
|
|
proc BuildRetVoid*(para1: BuilderRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildRetVoid".}
|
|
proc BuildRet*(para1: BuilderRef, V: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMBuildRet".}
|
|
proc BuildAggregateRet*(para1: BuilderRef, RetVals: ptr ValueRef, N: int32): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildAggregateRet".}
|
|
proc BuildBr*(para1: BuilderRef, Dest: BasicBlockRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMBuildBr".}
|
|
proc BuildCondBr*(para1: BuilderRef, Cond: ValueRef, ThenBranch: BasicBlockRef,
|
|
ElseBranch: BasicBlockRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildCondBr".}
|
|
proc BuildSwitch*(para1: BuilderRef, V: ValueRef, ElseBranch: BasicBlockRef,
|
|
NumCases: int32): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildSwitch".}
|
|
proc BuildInvoke*(para1: BuilderRef, Fn: ValueRef, Args: ptr ValueRef,
|
|
NumArgs: int32, ThenBranch: BasicBlockRef,
|
|
Catch: BasicBlockRef, Name: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMBuildInvoke".}
|
|
proc BuildUnwind*(para1: BuilderRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildUnwind".}
|
|
proc BuildUnreachable*(para1: BuilderRef): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildUnreachable".}
|
|
# Add a case to the switch instruction
|
|
proc AddCase*(Switch: ValueRef, OnVal: ValueRef, Dest: BasicBlockRef){.cdecl,
|
|
dynlib: libname, importc: "LLVMAddCase".}
|
|
# Arithmetic
|
|
proc BuildAdd*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildAdd".}
|
|
proc BuildNSWAdd*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildNSWAdd".}
|
|
proc BuildFAdd*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildFAdd".}
|
|
proc BuildSub*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildSub".}
|
|
proc BuildFSub*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildFSub".}
|
|
proc BuildMul*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildMul".}
|
|
proc BuildFMul*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildFMul".}
|
|
proc BuildUDiv*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildUDiv".}
|
|
proc BuildSDiv*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildSDiv".}
|
|
proc BuildExactSDiv*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildExactSDiv".}
|
|
proc BuildFDiv*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildFDiv".}
|
|
proc BuildURem*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildURem".}
|
|
proc BuildSRem*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildSRem".}
|
|
proc BuildFRem*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildFRem".}
|
|
proc BuildShl*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildShl".}
|
|
proc BuildLShr*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildLShr".}
|
|
proc BuildAShr*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildAShr".}
|
|
proc BuildAnd*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildAnd".}
|
|
proc BuildOr*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildOr".}
|
|
proc BuildXor*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildXor".}
|
|
proc BuildNeg*(para1: BuilderRef, V: ValueRef, Name: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMBuildNeg".}
|
|
proc BuildFNeg*(para1: BuilderRef, V: ValueRef, Name: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMBuildFNeg".}
|
|
proc BuildNot*(para1: BuilderRef, V: ValueRef, Name: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMBuildNot".}
|
|
# Memory
|
|
proc BuildMalloc*(para1: BuilderRef, Ty: TypeRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildMalloc".}
|
|
proc BuildArrayMalloc*(para1: BuilderRef, Ty: TypeRef, Val: ValueRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildArrayMalloc".}
|
|
proc BuildAlloca*(para1: BuilderRef, Ty: TypeRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildAlloca".}
|
|
proc BuildArrayAlloca*(para1: BuilderRef, Ty: TypeRef, Val: ValueRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildArrayAlloca".}
|
|
proc BuildFree*(para1: BuilderRef, PointerVal: ValueRef): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMBuildFree".}
|
|
proc BuildLoad*(para1: BuilderRef, PointerVal: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildLoad".}
|
|
proc BuildStore*(para1: BuilderRef, Val: ValueRef, thePtr: ValueRef): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildStore".}
|
|
proc BuildGEP*(B: BuilderRef, Pointer: ValueRef, Indices: ptr ValueRef,
|
|
NumIndices: int32, Name: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMBuildGEP".}
|
|
proc BuildInBoundsGEP*(B: BuilderRef, Pointer: ValueRef, Indices: ptr ValueRef,
|
|
NumIndices: int32, Name: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMBuildInBoundsGEP".}
|
|
proc BuildStructGEP*(B: BuilderRef, Pointer: ValueRef, Idx: int32, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildStructGEP".}
|
|
proc BuildGlobalString*(B: BuilderRef, Str: cstring, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildGlobalString".}
|
|
proc BuildGlobalStringPtr*(B: BuilderRef, Str: cstring, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildGlobalStringPtr".}
|
|
# Casts
|
|
proc BuildTrunc*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildTrunc".}
|
|
proc BuildZExt*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildZExt".}
|
|
proc BuildSExt*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildSExt".}
|
|
proc BuildFPToUI*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildFPToUI".}
|
|
proc BuildFPToSI*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildFPToSI".}
|
|
proc BuildUIToFP*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildUIToFP".}
|
|
proc BuildSIToFP*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildSIToFP".}
|
|
proc BuildFPTrunc*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildFPTrunc".}
|
|
proc BuildFPExt*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildFPExt".}
|
|
proc BuildPtrToInt*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildPtrToInt".}
|
|
proc BuildIntToPtr*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildIntToPtr".}
|
|
proc BuildBitCast*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildBitCast".}
|
|
proc BuildZExtOrBitCast*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildZExtOrBitCast".}
|
|
proc BuildSExtOrBitCast*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildSExtOrBitCast".}
|
|
proc BuildTruncOrBitCast*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildTruncOrBitCast".}
|
|
proc BuildPointerCast*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildPointerCast".}
|
|
proc BuildIntCast*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildIntCast".}
|
|
proc BuildFPCast*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildFPCast".}
|
|
# Comparisons
|
|
proc BuildICmp*(para1: BuilderRef, Op: IntPredicate, LHS: ValueRef,
|
|
RHS: ValueRef, Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildICmp".}
|
|
proc BuildFCmp*(para1: BuilderRef, Op: RealPredicate, LHS: ValueRef,
|
|
RHS: ValueRef, Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildFCmp".}
|
|
# Miscellaneous instructions
|
|
proc BuildPhi*(para1: BuilderRef, Ty: TypeRef, Name: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMBuildPhi".}
|
|
proc BuildCall*(para1: BuilderRef, Fn: ValueRef, Args: ptr ValueRef,
|
|
NumArgs: int32, Name: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMBuildCall".}
|
|
proc BuildSelect*(para1: BuilderRef, Cond: ValueRef, ThenBranch: ValueRef,
|
|
ElseBranch: ValueRef, Name: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMBuildSelect".}
|
|
proc BuildVAArg*(para1: BuilderRef, List: ValueRef, Ty: TypeRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildVAArg".}
|
|
proc BuildExtractElement*(para1: BuilderRef, VecVal: ValueRef, Index: ValueRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildExtractElement".}
|
|
proc BuildInsertElement*(para1: BuilderRef, VecVal: ValueRef, EltVal: ValueRef,
|
|
Index: ValueRef, Name: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMBuildInsertElement".}
|
|
proc BuildShuffleVector*(para1: BuilderRef, V1: ValueRef, V2: ValueRef,
|
|
Mask: ValueRef, Name: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMBuildShuffleVector".}
|
|
proc BuildExtractValue*(para1: BuilderRef, AggVal: ValueRef, Index: int32,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildExtractValue".}
|
|
proc BuildInsertValue*(para1: BuilderRef, AggVal: ValueRef, EltVal: ValueRef,
|
|
Index: int32, Name: cstring): ValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMBuildInsertValue".}
|
|
proc BuildIsNull*(para1: BuilderRef, Val: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildIsNull".}
|
|
proc BuildIsNotNull*(para1: BuilderRef, Val: ValueRef, Name: cstring): ValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMBuildIsNotNull".}
|
|
proc BuildPtrDiff*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef,
|
|
Name: cstring): ValueRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMBuildPtrDiff".}
|
|
#===-- Module providers --------------------------------------------------===
|
|
# Encapsulates the module M in a module provider, taking ownership of the
|
|
# module.
|
|
# See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
|
|
#
|
|
proc CreateModuleProviderForExistingModule*(M: ModuleRef): ModuleProviderRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMCreateModuleProviderForExistingModule".}
|
|
# Destroys the module provider MP as well as the contained module.
|
|
# See the destructor llvm::ModuleProvider::~ModuleProvider.
|
|
#
|
|
proc DisposeModuleProvider*(MP: ModuleProviderRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMDisposeModuleProvider".}
|
|
#===-- Memory buffers ----------------------------------------------------===
|
|
proc CreateMemoryBufferWithContentsOfFile*(Path: cstring,
|
|
OutMemBuf: ptr MemoryBufferRef, OutMessage: var cstring): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMCreateMemoryBufferWithContentsOfFile".}
|
|
proc CreateMemoryBufferWithSTDIN*(OutMemBuf: ptr MemoryBufferRef,
|
|
OutMessage: var cstring): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMCreateMemoryBufferWithSTDIN".}
|
|
proc DisposeMemoryBuffer*(MemBuf: MemoryBufferRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMDisposeMemoryBuffer".}
|
|
#===-- Pass Managers -----------------------------------------------------===
|
|
# Constructs a new whole-module pass pipeline. This type of pipeline is
|
|
# suitable for link-time optimization and whole-module transformations.
|
|
# See llvm::PassManager::PassManager.
|
|
proc CreatePassManager*(): PassManagerRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMCreatePassManager".}
|
|
# Constructs a new function-by-function pass pipeline over the module
|
|
# provider. It does not take ownership of the module provider. This type of
|
|
# pipeline is suitable for code generation and JIT compilation tasks.
|
|
# See llvm::FunctionPassManager::FunctionPassManager.
|
|
proc CreateFunctionPassManager*(MP: ModuleProviderRef): PassManagerRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMCreateFunctionPassManager".}
|
|
# Initializes, executes on the provided module, and finalizes all of the
|
|
# passes scheduled in the pass manager. Returns 1 if any of the passes
|
|
# modified the module, 0 otherwise. See llvm::PassManager::run(Module&).
|
|
proc RunPassManager*(PM: PassManagerRef, M: ModuleRef): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMRunPassManager".}
|
|
# Initializes all of the function passes scheduled in the function pass
|
|
# manager. Returns 1 if any of the passes modified the module, 0 otherwise.
|
|
# See llvm::FunctionPassManager::doInitialization.
|
|
proc InitializeFunctionPassManager*(FPM: PassManagerRef): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMInitializeFunctionPassManager".}
|
|
# Executes all of the function passes scheduled in the function pass manager
|
|
# on the provided function. Returns 1 if any of the passes modified the
|
|
# function, false otherwise.
|
|
# See llvm::FunctionPassManager::run(Function&).
|
|
proc RunFunctionPassManager*(FPM: PassManagerRef, F: ValueRef): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMRunFunctionPassManager".}
|
|
# Finalizes all of the function passes scheduled in in the function pass
|
|
# manager. Returns 1 if any of the passes modified the module, 0 otherwise.
|
|
# See llvm::FunctionPassManager::doFinalization.
|
|
proc FinalizeFunctionPassManager*(FPM: PassManagerRef): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMFinalizeFunctionPassManager".}
|
|
# Frees the memory of a pass pipeline. For function pipelines, does not free
|
|
# the module provider.
|
|
# See llvm::PassManagerBase::~PassManagerBase.
|
|
proc DisposePassManager*(PM: PassManagerRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMDisposePassManager".}
|
|
# Analysis.h
|
|
# verifier will print to stderr and abort()
|
|
# verifier will print to stderr and return 1
|
|
# verifier will just return 1
|
|
type
|
|
VerifierFailureAction* = enum # Verifies that a module is valid, taking the specified action if not.
|
|
# Optionally returns a human-readable description of any invalid constructs.
|
|
# OutMessage must be disposed with LLVMDisposeMessage.
|
|
AbortProcessAction, PrintMessageAction, ReturnStatusAction
|
|
|
|
proc VerifyModule*(M: ModuleRef, Action: VerifierFailureAction,
|
|
OutMessage: var cstring): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMVerifyModule".}
|
|
# Verifies that a single function is valid, taking the specified action. Useful
|
|
# for debugging.
|
|
proc VerifyFunction*(Fn: ValueRef, Action: VerifierFailureAction): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMVerifyFunction".}
|
|
# Open up a ghostview window that displays the CFG of the current function.
|
|
# Useful for debugging.
|
|
proc ViewFunctionCFG*(Fn: ValueRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMViewFunctionCFG".}
|
|
proc ViewFunctionCFGOnly*(Fn: ValueRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMViewFunctionCFGOnly".}
|
|
# BitReader.h
|
|
# Builds a module from the bitcode in the specified memory buffer, returning a
|
|
# reference to the module via the OutModule parameter. Returns 0 on success.
|
|
# Optionally returns a human-readable error message via OutMessage.
|
|
proc ParseBitcode*(MemBuf: MemoryBufferRef, OutModule: var ModuleRef,
|
|
OutMessage: var cstring): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMParseBitcode".}
|
|
proc ParseBitcodeInContext*(ContextRef: ContextRef, MemBuf: MemoryBufferRef,
|
|
OutModule: var ModuleRef, OutMessage: var cstring): int32{.
|
|
cdecl, dynlib: libname, importc: "LLVMParseBitcodeInContext".}
|
|
# Reads a module from the specified path, returning via the OutMP parameter
|
|
# a module provider which performs lazy deserialization. Returns 0 on success.
|
|
# Optionally returns a human-readable error message via OutMessage.
|
|
proc GetBitcodeModuleProvider*(MemBuf: MemoryBufferRef,
|
|
OutMP: var ModuleProviderRef,
|
|
OutMessage: var cstring): int32{.
|
|
cdecl, dynlib: libname, importc: "LLVMGetBitcodeModuleProvider".}
|
|
proc GetBitcodeModuleProviderInContext*(ContextRef: ContextRef,
|
|
MemBuf: MemoryBufferRef,
|
|
OutMP: var ModuleProviderRef,
|
|
OutMessage: var cstring): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMGetBitcodeModuleProviderInContext".}
|
|
# BitWriter.h
|
|
#===-- Operations on modules ---------------------------------------------===
|
|
# Writes a module to an open file descriptor. Returns 0 on success.
|
|
# Closes the Handle. Use dup first if this is not what you want.
|
|
proc WriteBitcodeToFileHandle*(M: ModuleRef, Handle: int32): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMWriteBitcodeToFileHandle".}
|
|
# Writes a module to the specified path. Returns 0 on success.
|
|
proc WriteBitcodeToFile*(M: ModuleRef, Path: cstring): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMWriteBitcodeToFile".}
|
|
# Target.h
|
|
const
|
|
BigEndian* = 0
|
|
LittleEndian* = 1
|
|
|
|
type
|
|
ByteOrdering* = int32
|
|
OpaqueTargetData {.pure} = object
|
|
StructLayout {.pure} = object
|
|
TargetDataRef* = ref OpaqueTargetData
|
|
StructLayoutRef* = ref StructLayout
|
|
|
|
|
|
#===-- Target Data -------------------------------------------------------===
|
|
# Creates target data from a target layout string.
|
|
# See the constructor llvm::TargetData::TargetData.
|
|
|
|
proc CreateTargetData*(StringRep: cstring): TargetDataRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMCreateTargetData".}
|
|
# Adds target data information to a pass manager. This does not take ownership
|
|
# of the target data.
|
|
# See the method llvm::PassManagerBase::add.
|
|
proc AddTargetData*(para1: TargetDataRef, para2: PassManagerRef){.cdecl,
|
|
dynlib: libname, importc: "LLVMAddTargetData".}
|
|
# Converts target data to a target layout string. The string must be disposed
|
|
# with LLVMDisposeMessage.
|
|
# See the constructor llvm::TargetData::TargetData.
|
|
proc CopyStringRepOfTargetData*(para1: TargetDataRef): cstring{.cdecl,
|
|
dynlib: libname, importc: "LLVMCopyStringRepOfTargetData".}
|
|
# Returns the byte order of a target, either LLVMBigEndian or
|
|
# LLVMLittleEndian.
|
|
# See the method llvm::TargetData::isLittleEndian.
|
|
proc ByteOrder*(para1: TargetDataRef): ByteOrdering{.cdecl, dynlib: libname,
|
|
importc: "LLVMByteOrder".}
|
|
# Returns the pointer size in bytes for a target.
|
|
# See the method llvm::TargetData::getPointerSize.
|
|
proc PointerSize*(para1: TargetDataRef): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMPointerSize".}
|
|
# Returns the integer type that is the same size as a pointer on a target.
|
|
# See the method llvm::TargetData::getIntPtrType.
|
|
proc IntPtrType*(para1: TargetDataRef): TypeRef{.cdecl, dynlib: libname,
|
|
importc: "LLVMIntPtrType".}
|
|
# Computes the size of a type in bytes for a target.
|
|
# See the method llvm::TargetData::getTypeSizeInBits.
|
|
proc SizeOfTypeInBits*(para1: TargetDataRef, para2: TypeRef): int64{.cdecl,
|
|
dynlib: libname, importc: "LLVMSizeOfTypeInBits".}
|
|
# Computes the storage size of a type in bytes for a target.
|
|
# See the method llvm::TargetData::getTypeStoreSize.
|
|
proc StoreSizeOfType*(para1: TargetDataRef, para2: TypeRef): int64{.cdecl,
|
|
dynlib: libname, importc: "LLVMStoreSizeOfType".}
|
|
# Computes the ABI size of a type in bytes for a target.
|
|
# See the method llvm::TargetData::getTypeAllocSize.
|
|
proc ABISizeOfType*(para1: TargetDataRef, para2: TypeRef): int64{.cdecl,
|
|
dynlib: libname, importc: "LLVMABISizeOfType".}
|
|
# Computes the ABI alignment of a type in bytes for a target.
|
|
# See the method llvm::TargetData::getTypeABISize.
|
|
proc ABIAlignmentOfType*(para1: TargetDataRef, para2: TypeRef): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMABIAlignmentOfType".}
|
|
# Computes the call frame alignment of a type in bytes for a target.
|
|
# See the method llvm::TargetData::getTypeABISize.
|
|
proc CallFrameAlignmentOfType*(para1: TargetDataRef, para2: TypeRef): int32{.
|
|
cdecl, dynlib: libname, importc: "LLVMCallFrameAlignmentOfType".}
|
|
# Computes the preferred alignment of a type in bytes for a target.
|
|
# See the method llvm::TargetData::getTypeABISize.
|
|
proc PreferredAlignmentOfType*(para1: TargetDataRef, para2: TypeRef): int32{.
|
|
cdecl, dynlib: libname, importc: "LLVMPreferredAlignmentOfType".}
|
|
# Computes the preferred alignment of a global variable in bytes for a target.
|
|
# See the method llvm::TargetData::getPreferredAlignment.
|
|
proc PreferredAlignmentOfGlobal*(para1: TargetDataRef, GlobalVar: ValueRef): int32{.
|
|
cdecl, dynlib: libname, importc: "LLVMPreferredAlignmentOfGlobal".}
|
|
# Computes the structure element that contains the byte offset for a target.
|
|
# See the method llvm::StructLayout::getElementContainingOffset.
|
|
proc ElementAtOffset*(para1: TargetDataRef, StructTy: TypeRef, Offset: int64): int32{.
|
|
cdecl, dynlib: libname, importc: "LLVMElementAtOffset".}
|
|
# Computes the byte offset of the indexed struct element for a target.
|
|
# See the method llvm::StructLayout::getElementContainingOffset.
|
|
proc OffsetOfElement*(para1: TargetDataRef, StructTy: TypeRef, Element: int32): int64{.
|
|
cdecl, dynlib: libname, importc: "LLVMOffsetOfElement".}
|
|
# Struct layouts are speculatively cached. If a TargetDataRef is alive when
|
|
# types are being refined and removed, this method must be called whenever a
|
|
# struct type is removed to avoid a dangling pointer in this cache.
|
|
# See the method llvm::TargetData::InvalidateStructLayoutInfo.
|
|
proc InvalidateStructLayout*(para1: TargetDataRef, StructTy: TypeRef){.cdecl,
|
|
dynlib: libname, importc: "LLVMInvalidateStructLayout".}
|
|
# Deallocates a TargetData.
|
|
# See the destructor llvm::TargetData::~TargetData.
|
|
proc DisposeTargetData*(para1: TargetDataRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMDisposeTargetData".}
|
|
# ExecutionEngine.h
|
|
proc LinkInJIT*(){.cdecl, dynlib: libname, importc: "LLVMLinkInJIT".}
|
|
proc LinkInInterpreter*(){.cdecl, dynlib: libname,
|
|
importc: "LLVMLinkInInterpreter".}
|
|
type
|
|
OpaqueGenericValue {.pure} = object
|
|
OpaqueExecutionEngine {.pure} = object
|
|
GenericValueRef* = OpaqueGenericValue
|
|
ExecutionEngineRef* = OpaqueExecutionEngine
|
|
|
|
#===-- Operations on generic values --------------------------------------===
|
|
|
|
proc CreateGenericValueOfInt*(Ty: TypeRef, N: int64, IsSigned: int32): GenericValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMCreateGenericValueOfInt".}
|
|
proc CreateGenericValueOfPointer*(P: pointer): GenericValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMCreateGenericValueOfPointer".}
|
|
proc CreateGenericValueOfFloat*(Ty: TypeRef, N: float64): GenericValueRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMCreateGenericValueOfFloat".}
|
|
proc GenericValueIntWidth*(GenValRef: GenericValueRef): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMGenericValueIntWidth".}
|
|
proc GenericValueToInt*(GenVal: GenericValueRef, IsSigned: int32): int64{.cdecl,
|
|
dynlib: libname, importc: "LLVMGenericValueToInt".}
|
|
proc GenericValueToPointer*(GenVal: GenericValueRef): pointer{.cdecl,
|
|
dynlib: libname, importc: "LLVMGenericValueToPointer".}
|
|
proc GenericValueToFloat*(TyRef: TypeRef, GenVal: GenericValueRef): float64{.
|
|
cdecl, dynlib: libname, importc: "LLVMGenericValueToFloat".}
|
|
proc DisposeGenericValue*(GenVal: GenericValueRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMDisposeGenericValue".}
|
|
|
|
#===-- Operations on execution engines -----------------------------------===
|
|
proc CreateExecutionEngine*(OutEE: var ExecutionEngineRef, MP: ModuleProviderRef,
|
|
OutError: var cstring): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMCreateExecutionEngine".}
|
|
proc CreateInterpreter*(OutInterp: var ExecutionEngineRef, MP: ModuleProviderRef,
|
|
OutError: var cstring): int32{.cdecl, dynlib: libname,
|
|
importc: "LLVMCreateInterpreter".}
|
|
proc CreateJITCompiler*(OutJIT: var ExecutionEngineRef, MP: ModuleProviderRef,
|
|
OptLevel: int32, OutError: var cstring): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMCreateJITCompiler".}
|
|
proc DisposeExecutionEngine*(EE: ExecutionEngineRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMDisposeExecutionEngine".}
|
|
proc RunStaticConstructors*(EE: ExecutionEngineRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMRunStaticConstructors".}
|
|
proc RunStaticDestructors*(EE: ExecutionEngineRef){.cdecl, dynlib: libname,
|
|
importc: "LLVMRunStaticDestructors".}
|
|
|
|
proc RunFunctionAsMain*(EE: ExecutionEngineRef, F: ValueRef, ArgC: int32,
|
|
ArgV: cstringArray, EnvP: cstringArray): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMRunFunctionAsMain".}
|
|
proc RunFunction*(EE: ExecutionEngineRef, F: ValueRef, NumArgs: int32,
|
|
Args: ptr GenericValueRef): GenericValueRef{.cdecl,
|
|
dynlib: libname, importc: "LLVMRunFunction".}
|
|
proc FreeMachineCodeForFunction*(EE: ExecutionEngineRef, F: ValueRef){.cdecl,
|
|
dynlib: libname, importc: "LLVMFreeMachineCodeForFunction".}
|
|
proc AddModuleProvider*(EE: ExecutionEngineRef, MP: ModuleProviderRef){.cdecl,
|
|
dynlib: libname, importc: "LLVMAddModuleProvider".}
|
|
proc RemoveModuleProvider*(EE: ExecutionEngineRef, MP: ModuleProviderRef,
|
|
OutMod: var ModuleRef, OutError: var cstring): int32{.cdecl,
|
|
dynlib: libname, importc: "LLVMRemoveModuleProvider".}
|
|
proc FindFunction*(EE: ExecutionEngineRef, Name: cstring, OutFn: var ValueRef): int32{.
|
|
cdecl, dynlib: libname, importc: "LLVMFindFunction".}
|
|
proc GetExecutionEngineTargetData*(EE: ExecutionEngineRef): TargetDataRef{.
|
|
cdecl, dynlib: libname, importc: "LLVMGetExecutionEngineTargetData".}
|
|
proc AddGlobalMapping*(EE: ExecutionEngineRef, Global: ValueRef,
|
|
theAddr: pointer){.cdecl, dynlib: libname,
|
|
importc: "LLVMAddGlobalMapping".}
|
|
proc GetPointerToGlobal*(EE: ExecutionEngineRef, Global: ValueRef): pointer{.
|
|
cdecl, dynlib: libname, importc: "LLVMGetPointerToGlobal".}
|
|
|
|
# LinkTimeOptimizer.h
|
|
# This provides a dummy type for pointers to the LTO object.
|
|
type
|
|
lto_t* = pointer
|
|
lto_status* = enum
|
|
LTO_UNKNOWN, LTO_OPT_SUCCESS, LTO_READ_SUCCESS, LTO_READ_FAILURE,
|
|
LTO_WRITE_FAILURE, LTO_NO_TARGET, LTO_NO_WORK, LTO_MODULE_MERGE_FAILURE,
|
|
LTO_ASM_FAILURE, LTO_NULL_OBJECT
|
|
lto_status_t* = lto_status
|
|
# This provides C interface to initialize link time optimizer. This allows
|
|
# linker to use dlopen() interface to dynamically load LinkTimeOptimizer.
|
|
# extern "C" helps, because dlopen() interface uses name to find the symbol.
|
|
|
|
proc create_optimizer*(): lto_t{.cdecl, dynlib: libname,
|
|
importc: "llvm_create_optimizer".}
|
|
proc destroy_optimizer*(lto: lto_t){.cdecl, dynlib: libname,
|
|
importc: "llvm_destroy_optimizer".}
|
|
proc read_object_file*(lto: lto_t, input_filename: cstring): lto_status_t{.
|
|
cdecl, dynlib: libname, importc: "llvm_read_object_file".}
|
|
proc optimize_modules*(lto: lto_t, output_filename: cstring): lto_status_t{.
|
|
cdecl, dynlib: libname, importc: "llvm_optimize_modules".}
|
|
|
|
# lto.h
|
|
const
|
|
LTO_API_VERSION* = 3 # log2 of alignment
|
|
|
|
type
|
|
lto_symbol_attributes* = enum
|
|
SYMBOL_ALIGNMENT_MASK = 0x0000001F,
|
|
SYMBOL_PERMISSIONS_RODATA = 0x00000080,
|
|
SYMBOL_PERMISSIONS_CODE = 0x000000A0,
|
|
SYMBOL_PERMISSIONS_DATA = 0x000000C0,
|
|
SYMBOL_PERMISSIONS_MASK = 0x000000E0,
|
|
|
|
SYMBOL_DEFINITION_REGULAR = 0x00000100,
|
|
SYMBOL_DEFINITION_TENTATIVE = 0x00000200,
|
|
SYMBOL_DEFINITION_WEAK = 0x00000300,
|
|
SYMBOL_DEFINITION_UNDEFINED = 0x00000400,
|
|
SYMBOL_DEFINITION_WEAKUNDEF = 0x00000500,
|
|
SYMBOL_DEFINITION_MASK = 0x00000700,
|
|
SYMBOL_SCOPE_INTERNAL = 0x00000800,
|
|
|
|
SYMBOL_SCOPE_HIDDEN = 0x00001000,
|
|
SYMBOL_SCOPE_DEFAULT = 0x00001800,
|
|
SYMBOL_SCOPE_PROTECTED = 0x00002000,
|
|
SYMBOL_SCOPE_MASK = 0x00003800,
|
|
lto_debug_model* = enum
|
|
DEBUG_MODEL_NONE = 0, DEBUG_MODEL_DWARF = 1
|
|
lto_codegen_model* = enum
|
|
CODEGEN_PIC_MODEL_STATIC = 0, CODEGEN_PIC_MODEL_DYNAMIC = 1,
|
|
CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC = 2
|
|
|
|
LTOModule {.pure} = object
|
|
LTOCodeGenerator {.pure} = object
|
|
lto_module_t* = ref LTOModule
|
|
lto_code_gen_t* = ref LTOCodeGenerator
|
|
|
|
proc lto_get_version*(): cstring{.cdecl, dynlib: libname,
|
|
importc: "lto_get_version".}
|
|
#
|
|
# Returns the last error string or NULL if last operation was sucessful.
|
|
#
|
|
proc lto_get_error_message*(): cstring{.cdecl, dynlib: libname,
|
|
importc: "lto_get_error_message".}
|
|
#
|
|
# Checks if a file is a loadable object file.
|
|
#
|
|
proc lto_module_is_object_file*(path: cstring): bool{.cdecl, dynlib: libname,
|
|
importc: "lto_module_is_object_file".}
|
|
#
|
|
# Checks if a file is a loadable object compiled for requested target.
|
|
#
|
|
proc lto_module_is_object_file_for_target*(path: cstring,
|
|
target_triple_prefix: cstring): bool{.cdecl, dynlib: libname,
|
|
importc: "lto_module_is_object_file_for_target".}
|
|
#
|
|
# Checks if a buffer is a loadable object file.
|
|
#
|
|
proc lto_module_is_object_file_in_memory*(mem: pointer, len: int): bool{.
|
|
cdecl, dynlib: libname, importc: "lto_module_is_object_file_in_memory".}
|
|
#
|
|
# Checks if a buffer is a loadable object compiled for requested target.
|
|
#
|
|
proc lto_module_is_object_file_in_memory_for_target*(mem: pointer, len: int,
|
|
target_triple_prefix: cstring): bool{.cdecl, dynlib: libname,
|
|
importc: "lto_module_is_object_file_in_memory_for_target".}
|
|
#
|
|
# Loads an object file from disk.
|
|
# Returns NULL on error (check lto_get_error_message() for details).
|
|
#
|
|
proc lto_module_create*(path: cstring): lto_module_t{.cdecl, dynlib: libname,
|
|
importc: "lto_module_create".}
|
|
#
|
|
# Loads an object file from memory.
|
|
# Returns NULL on error (check lto_get_error_message() for details).
|
|
#
|
|
proc lto_module_create_from_memory*(mem: pointer, len: int): lto_module_t{.
|
|
cdecl, dynlib: libname, importc: "lto_module_create_from_memory".}
|
|
#
|
|
# Frees all memory internally allocated by the module.
|
|
# Upon return the lto_module_t is no longer valid.
|
|
#
|
|
proc lto_module_dispose*(module: lto_module_t){.cdecl, dynlib: libname,
|
|
importc: "lto_module_dispose".}
|
|
#
|
|
# Returns triple string which the object module was compiled under.
|
|
#
|
|
proc lto_module_get_target_triple*(module: lto_module_t): cstring{.cdecl,
|
|
dynlib: libname, importc: "lto_module_get_target_triple".}
|
|
#
|
|
# Returns the number of symbols in the object module.
|
|
#
|
|
proc lto_module_get_num_symbols*(module: lto_module_t): int32{.cdecl,
|
|
dynlib: libname, importc: "lto_module_get_num_symbols".}
|
|
#
|
|
# Returns the name of the ith symbol in the object module.
|
|
#
|
|
proc lto_module_get_symbol_name*(module: lto_module_t, index: int32): cstring{.
|
|
cdecl, dynlib: libname, importc: "lto_module_get_symbol_name".}
|
|
#
|
|
# Returns the attributes of the ith symbol in the object module.
|
|
#
|
|
proc lto_module_get_symbol_attribute*(module: lto_module_t, index: int32): lto_symbol_attributes{.
|
|
cdecl, dynlib: libname, importc: "lto_module_get_symbol_attribute".}
|
|
#
|
|
# Instantiates a code generator.
|
|
# Returns NULL on error (check lto_get_error_message() for details).
|
|
#
|
|
proc lto_codegen_create*(): lto_code_gen_t{.cdecl, dynlib: libname,
|
|
importc: "lto_codegen_create".}
|
|
#
|
|
# Frees all code generator and all memory it internally allocated.
|
|
# Upon return the lto_code_gen_t is no longer valid.
|
|
#
|
|
proc lto_codegen_dispose*(para1: lto_code_gen_t){.cdecl, dynlib: libname,
|
|
importc: "lto_codegen_dispose".}
|
|
#
|
|
# Add an object module to the set of modules for which code will be generated.
|
|
# Returns true on error (check lto_get_error_message() for details).
|
|
#
|
|
proc lto_codegen_add_module*(cg: lto_code_gen_t, module: lto_module_t): bool{.
|
|
cdecl, dynlib: libname, importc: "lto_codegen_add_module".}
|
|
#
|
|
# Sets if debug info should be generated.
|
|
# Returns true on error (check lto_get_error_message() for details).
|
|
#
|
|
proc lto_codegen_set_debug_model*(cg: lto_code_gen_t, para2: lto_debug_model): bool{.
|
|
cdecl, dynlib: libname, importc: "lto_codegen_set_debug_model".}
|
|
#
|
|
# Sets which PIC code model to generated.
|
|
# Returns true on error (check lto_get_error_message() for details).
|
|
#
|
|
proc lto_codegen_set_pic_model*(cg: lto_code_gen_t, para2: lto_codegen_model): bool{.
|
|
cdecl, dynlib: libname, importc: "lto_codegen_set_pic_model".}
|
|
#
|
|
# Sets the location of the "gcc" to run. If not set, libLTO will search for
|
|
# "gcc" on the path.
|
|
#
|
|
proc lto_codegen_set_gcc_path*(cg: lto_code_gen_t, path: cstring){.cdecl,
|
|
dynlib: libname, importc: "lto_codegen_set_gcc_path".}
|
|
#
|
|
# Sets the location of the assembler tool to run. If not set, libLTO
|
|
# will use gcc to invoke the assembler.
|
|
#
|
|
proc lto_codegen_set_assembler_path*(cg: lto_code_gen_t, path: cstring){.cdecl,
|
|
dynlib: libname, importc: "lto_codegen_set_assembler_path".}
|
|
#
|
|
# Adds to a list of all global symbols that must exist in the final
|
|
# generated code. If a function is not listed, it might be
|
|
# inlined into every usage and optimized away.
|
|
#
|
|
proc lto_codegen_add_must_preserve_symbol*(cg: lto_code_gen_t, symbol: cstring){.
|
|
cdecl, dynlib: libname, importc: "lto_codegen_add_must_preserve_symbol".}
|
|
#
|
|
# Writes a new object file at the specified path that contains the
|
|
# merged contents of all modules added so far.
|
|
# Returns true on error (check lto_get_error_message() for details).
|
|
#
|
|
proc lto_codegen_write_merged_modules*(cg: lto_code_gen_t, path: cstring): bool{.
|
|
cdecl, dynlib: libname, importc: "lto_codegen_write_merged_modules".}
|
|
#
|
|
# Generates code for all added modules into one native object file.
|
|
# On sucess returns a pointer to a generated mach-o/ELF buffer and
|
|
# length set to the buffer size. The buffer is owned by the
|
|
# lto_code_gen_t and will be freed when lto_codegen_dispose()
|
|
# is called, or lto_codegen_compile() is called again.
|
|
# On failure, returns NULL (check lto_get_error_message() for details).
|
|
#
|
|
proc lto_codegen_compile*(cg: lto_code_gen_t, len: var int): pointer{.cdecl,
|
|
dynlib: libname, importc: "lto_codegen_compile".}
|
|
#
|
|
# Sets options to help debug codegen bugs.
|
|
#
|
|
proc lto_codegen_debug_options*(cg: lto_code_gen_t, para2: cstring){.cdecl,
|
|
dynlib: libname, importc: "lto_codegen_debug_options".}
|