diff options
Diffstat (limited to 'llvm/llvm.nim')
| -rw-r--r-- | llvm/llvm.nim | 1452 |
1 files changed, 1452 insertions, 0 deletions
diff --git a/llvm/llvm.nim b/llvm/llvm.nim new file mode 100644 index 000000000..d010457f8 --- /dev/null +++ b/llvm/llvm.nim @@ -0,0 +1,1452 @@ +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".} |