const libname* = "" #Setup as you need type PLLVMBasicBlockRef* = ptr LLVMBasicBlockRef PLLVMExecutionEngineRef* = ptr LLVMExecutionEngineRef PLLVMGenericValueRef* = ptr LLVMGenericValueRef PLLVMMemoryBufferRef* = ptr LLVMMemoryBufferRef PLLVMModuleProviderRef* = ptr LLVMModuleProviderRef PLLVMModuleRef* = ptr LLVMModuleRef PLLVMTypeRef* = ptr LLVMTypeRef PLLVMValueRef* = ptr LLVMValueRef # Core.h # Opaque types. #* # * The top-level container for all LLVM global data. See the LLVMContext class. # type LLVMContextRef* = LLVMOpaqueContext #* # * The top-level container for all other LLVM Intermediate Representation (IR) # * objects. See the llvm::Module class. # LLVMModuleRef* = LLVMOpaqueModule #* # * Each value in the LLVM IR has a type, an LLVMTypeRef. See the llvm::Type # * class. # LLVMTypeRef* = LLVMOpaqueType #* # * When building recursive types using LLVMRefineType, LLVMTypeRef values may # * become invalid; use LLVMTypeHandleRef to resolve this problem. See the # * llvm::AbstractTypeHolder class. # LLVMTypeHandleRef* = LLVMOpaqueTypeHandle LLVMValueRef* = LLVMOpaqueValue LLVMBasicBlockRef* = LLVMOpaqueBasicBlock LLVMBuilderRef* = LLVMOpaqueBuilder # Used to provide a module to JIT or interpreter. # * See the llvm::ModuleProvider class. # LLVMModuleProviderRef* = LLVMOpaqueModuleProvider # Used to provide a module to JIT or interpreter. # * See the llvm::MemoryBuffer class. # LLVMMemoryBufferRef* = LLVMOpaqueMemoryBuffer #* See the llvm::PassManagerBase class. LLVMPassManagerRef* = LLVMOpaquePassManager #* # * Used to iterate through the uses of a Value, allowing access to all Values # * that use this Value. See the llvm::Use and llvm::value_use_iterator classes. # LLVMUseIteratorRef* = LLVMOpaqueUseIterator LLVMAttribute* = enum LLVMZExtAttribute = 1 shl 0, LLVMSExtAttribute = 1 shl 1, LLVMNoReturnAttribute = 1 shl 2, LLVMInRegAttribute = 1 shl 3, LLVMStructRetAttribute = 1 shl 4, LLVMNoUnwindAttribute = 1 shl 5, LLVMNoAliasAttribute = 1 shl 6, LLVMByValAttribute = 1 shl 7, LLVMNestAttribute = 1 shl 8, LLVMReadNoneAttribute = 1 shl 9, LLVMReadOnlyAttribute = 1 shl 10, LLVMNoInlineAttribute = 1 shl 11, LLVMAlwaysInlineAttribute = 1 shl 12, LLVMOptimizeForSizeAttribute = 1 shl 13, LLVMStackProtectAttribute = 1 shl 14, LLVMStackProtectReqAttribute = 1 shl 15, LLVMNoCaptureAttribute = 1 shl 21, LLVMNoRedZoneAttribute = 1 shl 22, LLVMNoImplicitFloatAttribute = 1 shl 23, LLVMNakedAttribute = 1 shl 24, LLVMInlineHintAttribute = 1 shl 25 LLVMOpcode* = enum #*< type with no size #*< 32 bit floating point type #*< 64 bit floating point type #*< 80 bit floating point type (X87) #*< 128 bit floating point type (112-bit mantissa) #*< 128 bit floating point type (two 64-bits) #*< Labels #*< Arbitrary bit width integers #*< Functions #*< Structures #*< Arrays #*< Pointers #*< Opaque: type with unknown structure #*< SIMD 'packed' format, or other vector type #*< Metadata LLVMRet = 1, LLVMBr = 2, LLVMSwitch = 3, LLVMInvoke = 4, LLVMUnwind = 5, LLVMUnreachable = 6, LLVMAdd = 7, LLVMFAdd = 8, LLVMSub = 9, LLVMFSub = 10, LLVMMul = 11, LLVMFMul = 12, LLVMUDiv = 13, LLVMSDiv = 14, LLVMFDiv = 15, LLVMURem = 16, LLVMSRem = 17, LLVMFRem = 18, LLVMShl = 19, LLVMLShr = 20, LLVMAShr = 21, LLVMAnd = 22, LLVMOr = 23, LLVMXor = 24, LLVMMalloc = 25, LLVMFree = 26, LLVMAlloca = 27, LLVMLoad = 28, LLVMStore = 29, LLVMGetElementPtr = 30, LLVMTrunk = 31, LLVMZExt = 32, LLVMSExt = 33, LLVMFPToUI = 34, LLVMFPToSI = 35, LLVMUIToFP = 36, LLVMSIToFP = 37, LLVMFPTrunc = 38, LLVMFPExt = 39, LLVMPtrToInt = 40, LLVMIntToPtr = 41, LLVMBitCast = 42, LLVMICmp = 43, LLVMFCmp = 44, LLVMPHI = 45, LLVMCall = 46, LLVMSelect = 47, LLVMVAArg = 50, LLVMExtractElement = 51, LLVMInsertElement = 52, LLVMShuffleVector = 53, LLVMExtractValue = 54, LLVMInsertValue = 55 LLVMTypeKind* = enum #*< Externally visible function #*< Keep one copy of function when linking (inline) #*< Same, but only replaced by something # equivalent. #*< Keep one copy of function when linking (weak) #*< Same, but only replaced by something # equivalent. #*< Special purpose, only applies to global arrays #*< Rename collisions when linking (static # functions) #*< Like Internal, but omit from symbol table #*< Function to be imported from DLL #*< Function to be accessible from DLL #*< ExternalWeak linkage description #*< Stand-in functions for streaming fns from # bitcode #*< Tentative definitions #*< Like Private, but linker removes. LLVMVoidTypeKind, LLVMFloatTypeKind, LLVMDoubleTypeKind, LLVMX86_FP80TypeKind, LLVMFP128TypeKind, LLVMPPC_FP128TypeKind, LLVMLabelTypeKind, LLVMIntegerTypeKind, LLVMFunctionTypeKind, LLVMStructTypeKind, LLVMArrayTypeKind, LLVMPointerTypeKind, LLVMOpaqueTypeKind, LLVMVectorTypeKind, LLVMMetadataTypeKind LLVMLinkage* = enum #*< The GV is visible #*< The GV is hidden #*< The GV is protected LLVMExternalLinkage, LLVMAvailableExternallyLinkage, LLVMLinkOnceAnyLinkage, LLVMLinkOnceODRLinkage, LLVMWeakAnyLinkage, LLVMWeakODRLinkage, LLVMAppendingLinkage, LLVMInternalLinkage, LLVMPrivateLinkage, LLVMDLLImportLinkage, LLVMDLLExportLinkage, LLVMExternalWeakLinkage, LLVMGhostLinkage, LLVMCommonLinkage, LLVMLinkerPrivateLinkage LLVMVisibility* = enum LLVMDefaultVisibility, LLVMHiddenVisibility, LLVMProtectedVisibility LLVMCallConv* = enum #*< equal #*< not equal #*< unsigned greater than #*< unsigned greater or equal #*< unsigned less than #*< unsigned less or equal #*< signed greater than #*< signed greater or equal #*< signed less than #*< signed less or equal LLVMCCallConv = 0, LLVMFastCallConv = 8, LLVMColdCallConv = 9, LLVMX86StdcallCallConv = 64, LLVMX86FastcallCallConv = 65 LLVMIntPredicate* = enum #*< Always false (always folded) #*< True if ordered and equal #*< True if ordered and greater than #*< True if ordered and greater than or equal #*< True if ordered and less than #*< True if ordered and less than or equal #*< True if ordered and operands are unequal #*< True if ordered (no nans) #*< True if unordered: isnan(X) | isnan(Y) #*< True if unordered or equal #*< True if unordered or greater than #*< True if unordered, greater than, or equal #*< True if unordered or less than #*< True if unordered, less than, or equal #*< True if unordered or not equal #*< Always true (always folded) LLVMIntEQ = 32, LLVMIntNE, LLVMIntUGT, LLVMIntUGE, LLVMIntULT, LLVMIntULE, LLVMIntSGT, LLVMIntSGE, LLVMIntSLT, LLVMIntSLE LLVMRealPredicate* = enum #===-- Error handling ----------------------------------------------------=== LLVMRealPredicateFalse, LLVMRealOEQ, LLVMRealOGT, LLVMRealOGE, LLVMRealOLT, LLVMRealOLE, LLVMRealONE, LLVMRealORD, LLVMRealUNO, LLVMRealUEQ, LLVMRealUGT, LLVMRealUGE, LLVMRealULT, LLVMRealULE, LLVMRealUNE, LLVMRealPredicateTrue proc LLVMDisposeMessage*(Message: cstring){.cdecl, dynlib: libname, importc: "LLVMDisposeMessage".} #===-- Modules -----------------------------------------------------------=== # Create and destroy contexts. proc LLVMContextCreate*(): LLVMContextRef{.cdecl, dynlib: libname, importc: "LLVMContextCreate".} proc LLVMGetGlobalContext*(): LLVMContextRef{.cdecl, dynlib: libname, importc: "LLVMGetGlobalContext".} proc LLVMContextDispose*(C: LLVMContextRef){.cdecl, dynlib: libname, importc: "LLVMContextDispose".} # Create and destroy modules. #* See llvm::Module::Module. proc LLVMModuleCreateWithName*(ModuleID: cstring): LLVMModuleRef{.cdecl, dynlib: libname, importc: "LLVMModuleCreateWithName".} proc LLVMModuleCreateWithNameInContext*(ModuleID: cstring, C: LLVMContextRef): LLVMModuleRef{. cdecl, dynlib: libname, importc: "LLVMModuleCreateWithNameInContext".} #* See llvm::Module::~Module. proc LLVMDisposeModule*(M: LLVMModuleRef){.cdecl, dynlib: libname, importc: "LLVMDisposeModule".} #* Data layout. See Module::getDataLayout. proc LLVMGetDataLayout*(M: LLVMModuleRef): cstring{.cdecl, dynlib: libname, importc: "LLVMGetDataLayout".} proc LLVMSetDataLayout*(M: LLVMModuleRef, Triple: cstring){.cdecl, dynlib: libname, importc: "LLVMSetDataLayout".} #* Target triple. See Module::getTargetTriple. proc LLVMGetTarget*(M: LLVMModuleRef): cstring{.cdecl, dynlib: libname, importc: "LLVMGetTarget".} proc LLVMSetTarget*(M: LLVMModuleRef, Triple: cstring){.cdecl, dynlib: libname, importc: "LLVMSetTarget".} #* See Module::addTypeName. proc LLVMAddTypeName*(M: LLVMModuleRef, Name: cstring, Ty: LLVMTypeRef): int32{. cdecl, dynlib: libname, importc: "LLVMAddTypeName".} proc LLVMDeleteTypeName*(M: LLVMModuleRef, Name: cstring){.cdecl, dynlib: libname, importc: "LLVMDeleteTypeName".} proc LLVMGetTypeByName*(M: LLVMModuleRef, Name: cstring): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMGetTypeByName".} #* See Module::dump. proc LLVMDumpModule*(M: LLVMModuleRef){.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 LLVMGetTypeKind*(Ty: LLVMTypeRef): LLVMTypeKind{.cdecl, dynlib: libname, importc: "LLVMGetTypeKind".} #* See llvm::LLVMType::getContext. proc LLVMGetTypeContext*(Ty: LLVMTypeRef): LLVMContextRef{.cdecl, dynlib: libname, importc: "LLVMGetTypeContext".} # Operations on integer types proc LLVMInt1TypeInContext*(C: LLVMContextRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMInt1TypeInContext".} proc LLVMInt8TypeInContext*(C: LLVMContextRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMInt8TypeInContext".} proc LLVMInt16TypeInContext*(C: LLVMContextRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMInt16TypeInContext".} proc LLVMInt32TypeInContext*(C: LLVMContextRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMInt32TypeInContext".} proc LLVMInt64TypeInContext*(C: LLVMContextRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMInt64TypeInContext".} proc LLVMIntTypeInContext*(C: LLVMContextRef, NumBits: dword): LLVMTypeRef{. cdecl, dynlib: libname, importc: "LLVMIntTypeInContext".} proc LLVMInt1Type*(): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMInt1Type".} proc LLVMInt8Type*(): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMInt8Type".} proc LLVMInt16Type*(): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMInt16Type".} proc LLVMInt32Type*(): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMInt32Type".} proc LLVMInt64Type*(): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMInt64Type".} proc LLVMIntType*(NumBits: dword): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMIntType".} proc LLVMGetIntTypeWidth*(IntegerTy: LLVMTypeRef): dword{.cdecl, dynlib: libname, importc: "LLVMGetIntTypeWidth".} # Operations on real types proc LLVMFloatTypeInContext*(C: LLVMContextRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMFloatTypeInContext".} proc LLVMDoubleTypeInContext*(C: LLVMContextRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMDoubleTypeInContext".} proc LLVMX86FP80TypeInContext*(C: LLVMContextRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMX86FP80TypeInContext".} proc LLVMFP128TypeInContext*(C: LLVMContextRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMFP128TypeInContext".} proc LLVMPPCFP128TypeInContext*(C: LLVMContextRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMPPCFP128TypeInContext".} proc LLVMFloatType*(): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMFloatType".} proc LLVMDoubleType*(): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMDoubleType".} proc LLVMX86FP80Type*(): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMX86FP80Type".} proc LLVMFP128Type*(): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMFP128Type".} proc LLVMPPCFP128Type*(): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMPPCFP128Type".} # Operations on function types proc LLVMFunctionType*(ReturnType: LLVMTypeRef, ParamTypes: pLLVMTypeRef, ParamCount: dword, IsVarArg: int32): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMFunctionType".} proc LLVMIsFunctionVarArg*(FunctionTy: LLVMTypeRef): int32{.cdecl, dynlib: libname, importc: "LLVMIsFunctionVarArg".} proc LLVMGetReturnType*(FunctionTy: LLVMTypeRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMGetReturnType".} proc LLVMCountParamTypes*(FunctionTy: LLVMTypeRef): dword{.cdecl, dynlib: libname, importc: "LLVMCountParamTypes".} proc LLVMGetParamTypes*(FunctionTy: LLVMTypeRef, Dest: pLLVMTypeRef){.cdecl, dynlib: libname, importc: "LLVMGetParamTypes".} # Operations on struct types proc LLVMStructTypeInContext*(C: LLVMContextRef, ElementTypes: pLLVMTypeRef, ElementCount: dword, isPacked: int32): LLVMTypeRef{. cdecl, dynlib: libname, importc: "LLVMStructTypeInContext".} proc LLVMStructType*(ElementTypes: pLLVMTypeRef, ElementCount: dword, isPacked: int32): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMStructType".} proc LLVMCountStructElementTypes*(StructTy: LLVMTypeRef): dword{.cdecl, dynlib: libname, importc: "LLVMCountStructElementTypes".} proc LLVMGetStructElementTypes*(StructTy: LLVMTypeRef, Dest: pLLVMTypeRef){. cdecl, dynlib: libname, importc: "LLVMGetStructElementTypes".} proc LLVMIsPackedStruct*(StructTy: LLVMTypeRef): int32{.cdecl, dynlib: libname, importc: "LLVMIsPackedStruct".} # Operations on array, pointer, and vector types (sequence types) proc LLVMArrayType*(ElementType: LLVMTypeRef, ElementCount: dword): LLVMTypeRef{. cdecl, dynlib: libname, importc: "LLVMArrayType".} proc LLVMPointerType*(ElementType: LLVMTypeRef, AddressSpace: dword): LLVMTypeRef{. cdecl, dynlib: libname, importc: "LLVMPointerType".} proc LLVMVectorType*(ElementType: LLVMTypeRef, ElementCount: dword): LLVMTypeRef{. cdecl, dynlib: libname, importc: "LLVMVectorType".} proc LLVMGetElementType*(Ty: LLVMTypeRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMGetElementType".} proc LLVMGetArrayLength*(ArrayTy: LLVMTypeRef): dword{.cdecl, dynlib: libname, importc: "LLVMGetArrayLength".} proc LLVMGetPointerAddressSpace*(PointerTy: LLVMTypeRef): dword{.cdecl, dynlib: libname, importc: "LLVMGetPointerAddressSpace".} proc LLVMGetVectorSize*(VectorTy: LLVMTypeRef): dword{.cdecl, dynlib: libname, importc: "LLVMGetVectorSize".} # Operations on other types proc LLVMVoidTypeInContext*(C: LLVMContextRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMVoidTypeInContext".} proc LLVMLabelTypeInContext*(C: LLVMContextRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMLabelTypeInContext".} proc LLVMOpaqueTypeInContext*(C: LLVMContextRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMOpaqueTypeInContext".} proc LLVMVoidType*(): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMVoidType".} proc LLVMLabelType*(): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMLabelType".} proc LLVMOpaqueType*(): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMOpaqueType".} # Operations on type handles proc LLVMCreateTypeHandle*(PotentiallyAbstractTy: LLVMTypeRef): LLVMTypeHandleRef{. cdecl, dynlib: libname, importc: "LLVMCreateTypeHandle".} proc LLVMRefineType*(AbstractTy: LLVMTypeRef, ConcreteTy: LLVMTypeRef){.cdecl, dynlib: libname, importc: "LLVMRefineType".} proc LLVMResolveTypeHandle*(TypeHandle: LLVMTypeHandleRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMResolveTypeHandle".} proc LLVMDisposeTypeHandle*(TypeHandle: LLVMTypeHandleRef){.cdecl, dynlib: libname, importc: "LLVMDisposeTypeHandle".} # Operations on all values proc LLVMTypeOf*(Val: LLVMValueRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMTypeOf".} proc LLVMGetValueName*(Val: LLVMValueRef): cstring{.cdecl, dynlib: libname, importc: "LLVMGetValueName".} proc LLVMSetValueName*(Val: LLVMValueRef, Name: cstring){.cdecl, dynlib: libname, importc: "LLVMSetValueName".} proc LLVMDumpValue*(Val: LLVMValueRef){.cdecl, dynlib: libname, importc: "LLVMDumpValue".} proc LLVMReplaceAllUsesWith*(OldVal: LLVMValueRef, NewVal: LLVMValueRef){.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 LLVMIsAArgument*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAArgument".} proc LLVMIsABasicBlock*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsABasicBlock".} proc LLVMIsAInlineAsm*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAInlineAsm".} proc LLVMIsAUser*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAUser".} proc LLVMIsAConstant*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAConstant".} proc LLVMIsAConstantAggregateZero*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAConstantAggregateZero".} proc LLVMIsAConstantArray*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAConstantArray".} proc LLVMIsAConstantExpr*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAConstantExpr".} proc LLVMIsAConstantFP*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAConstantFP".} proc LLVMIsAConstantInt*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAConstantInt".} proc LLVMIsAConstantPointerNull*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAConstantPointerNull".} proc LLVMIsAConstantStruct*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAConstantStruct".} proc LLVMIsAConstantVector*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAConstantVector".} proc LLVMIsAGlobalValue*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAGlobalValue".} proc LLVMIsAFunction*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAFunction".} proc LLVMIsAGlobalAlias*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAGlobalAlias".} proc LLVMIsAGlobalVariable*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAGlobalVariable".} proc LLVMIsAUndefValue*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAUndefValue".} proc LLVMIsAInstruction*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAInstruction".} proc LLVMIsABinaryOperator*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsABinaryOperator".} proc LLVMIsACallInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsACallInst".} proc LLVMIsAIntrinsicInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAIntrinsicInst".} proc LLVMIsADbgInfoIntrinsic*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsADbgInfoIntrinsic".} proc LLVMIsADbgDeclareInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsADbgDeclareInst".} proc LLVMIsADbgFuncStartInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsADbgFuncStartInst".} proc LLVMIsADbgRegionEndInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsADbgRegionEndInst".} proc LLVMIsADbgRegionStartInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsADbgRegionStartInst".} proc LLVMIsADbgStopPointInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsADbgStopPointInst".} proc LLVMIsAEHSelectorInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAEHSelectorInst".} proc LLVMIsAMemIntrinsic*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAMemIntrinsic".} proc LLVMIsAMemCpyInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAMemCpyInst".} proc LLVMIsAMemMoveInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAMemMoveInst".} proc LLVMIsAMemSetInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAMemSetInst".} proc LLVMIsACmpInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsACmpInst".} proc LLVMIsAFCmpInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAFCmpInst".} proc LLVMIsAICmpInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAICmpInst".} proc LLVMIsAExtractElementInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAExtractElementInst".} proc LLVMIsAGetElementPtrInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAGetElementPtrInst".} proc LLVMIsAInsertElementInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAInsertElementInst".} proc LLVMIsAInsertValueInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAInsertValueInst".} proc LLVMIsAPHINode*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAPHINode".} proc LLVMIsASelectInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsASelectInst".} proc LLVMIsAShuffleVectorInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAShuffleVectorInst".} proc LLVMIsAStoreInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAStoreInst".} proc LLVMIsATerminatorInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsATerminatorInst".} proc LLVMIsABranchInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsABranchInst".} proc LLVMIsAInvokeInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAInvokeInst".} proc LLVMIsAReturnInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAReturnInst".} proc LLVMIsASwitchInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsASwitchInst".} proc LLVMIsAUnreachableInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAUnreachableInst".} proc LLVMIsAUnwindInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAUnwindInst".} proc LLVMIsAUnaryInstruction*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAUnaryInstruction".} proc LLVMIsAAllocationInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAAllocationInst".} proc LLVMIsAAllocaInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAAllocaInst".} proc LLVMIsACastInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsACastInst".} proc LLVMIsABitCastInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsABitCastInst".} proc LLVMIsAFPExtInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAFPExtInst".} proc LLVMIsAFPToSIInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAFPToSIInst".} proc LLVMIsAFPToUIInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAFPToUIInst".} proc LLVMIsAFPTruncInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAFPTruncInst".} proc LLVMIsAIntToPtrInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAIntToPtrInst".} proc LLVMIsAPtrToIntInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAPtrToIntInst".} proc LLVMIsASExtInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsASExtInst".} proc LLVMIsASIToFPInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsASIToFPInst".} proc LLVMIsATruncInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsATruncInst".} proc LLVMIsAUIToFPInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAUIToFPInst".} proc LLVMIsAZExtInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAZExtInst".} proc LLVMIsAExtractValueInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAExtractValueInst".} proc LLVMIsAFreeInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAFreeInst".} proc LLVMIsALoadInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsALoadInst".} proc LLVMIsAVAArgInst*(Val: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMIsAVAArgInst".} # Operations on Uses proc LLVMGetFirstUse*(Val: LLVMValueRef): LLVMUseIteratorRef{.cdecl, dynlib: libname, importc: "LLVMGetFirstUse".} proc LLVMGetNextUse*(U: LLVMUseIteratorRef): LLVMUseIteratorRef{.cdecl, dynlib: libname, importc: "LLVMGetNextUse".} proc LLVMGetUser*(U: LLVMUseIteratorRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetUser".} proc LLVMGetUsedValue*(U: LLVMUseIteratorRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetUsedValue".} # Operations on Users proc LLVMGetOperand*(Val: LLVMValueRef, Index: dword): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetOperand".} # Operations on constants of any type proc LLVMConstNull*(Ty: LLVMTypeRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstNull".} # all zeroes proc LLVMConstAllOnes*(Ty: LLVMTypeRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstAllOnes".} # only for int/vector proc LLVMGetUndef*(Ty: LLVMTypeRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetUndef".} proc LLVMIsConstant*(Val: LLVMValueRef): int32{.cdecl, dynlib: libname, importc: "LLVMIsConstant".} proc LLVMIsNull*(Val: LLVMValueRef): int32{.cdecl, dynlib: libname, importc: "LLVMIsNull".} proc LLVMIsUndef*(Val: LLVMValueRef): int32{.cdecl, dynlib: libname, importc: "LLVMIsUndef".} proc LLVMConstPointerNull*(Ty: LLVMTypeRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstPointerNull".} # Operations on scalar constants proc LLVMConstInt*(IntTy: LLVMTypeRef, N: qword, SignExtend: int32): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstInt".} proc LLVMConstIntOfString*(IntTy: LLVMTypeRef, Text: cstring, Radix: uint8_t): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstIntOfString".} proc LLVMConstIntOfStringAndSize*(IntTy: LLVMTypeRef, Text: cstring, SLen: dword, Radix: uint8_t): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstIntOfStringAndSize".} proc LLVMConstReal*(RealTy: LLVMTypeRef, N: float64): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstReal".} proc LLVMConstRealOfString*(RealTy: LLVMTypeRef, Text: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstRealOfString".} proc LLVMConstRealOfStringAndSize*(RealTy: LLVMTypeRef, Text: cstring, SLen: dword): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstRealOfStringAndSize".} proc LLVMConstIntGetZExtValue*(ConstantVal: LLVMValueRef): qword{.cdecl, dynlib: libname, importc: "LLVMConstIntGetZExtValue".} proc LLVMConstIntGetSExtValue*(ConstantVal: LLVMValueRef): int64{.cdecl, dynlib: libname, importc: "LLVMConstIntGetSExtValue".} # Operations on composite constants proc LLVMConstStringInContext*(C: LLVMContextRef, Str: cstring, len: dword, DontNullTerminate: int32): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstStringInContext".} proc LLVMConstStructInContext*(C: LLVMContextRef, ConstantVals: pLLVMValueRef, Count: dword, isPacked: int32): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstStructInContext".} proc LLVMConstString*(Str: cstring, len: dword, DontNullTerminate: int32): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstString".} proc LLVMConstArray*(ElementTy: LLVMTypeRef, ConstantVals: pLLVMValueRef, len: dword): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstArray".} proc LLVMConstStruct*(ConstantVals: pLLVMValueRef, Count: dword, isPacked: int32): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstStruct".} proc LLVMConstVector*(ScalarConstantVals: pLLVMValueRef, Size: dword): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstVector".} # Constant expressions proc LLVMGetConstOpcode*(ConstantVal: LLVMValueRef): LLVMOpcode{.cdecl, dynlib: libname, importc: "LLVMGetConstOpcode".} proc LLVMAlignOf*(Ty: LLVMTypeRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMAlignOf".} proc LLVMSizeOf*(Ty: LLVMTypeRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMSizeOf".} proc LLVMConstNeg*(ConstantVal: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstNeg".} proc LLVMConstFNeg*(ConstantVal: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstFNeg".} proc LLVMConstNot*(ConstantVal: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstNot".} proc LLVMConstAdd*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstAdd".} proc LLVMConstNSWAdd*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstNSWAdd".} proc LLVMConstFAdd*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstFAdd".} proc LLVMConstSub*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstSub".} proc LLVMConstFSub*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstFSub".} proc LLVMConstMul*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstMul".} proc LLVMConstFMul*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstFMul".} proc LLVMConstUDiv*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstUDiv".} proc LLVMConstSDiv*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstSDiv".} proc LLVMConstExactSDiv*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstExactSDiv".} proc LLVMConstFDiv*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstFDiv".} proc LLVMConstURem*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstURem".} proc LLVMConstSRem*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstSRem".} proc LLVMConstFRem*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstFRem".} proc LLVMConstAnd*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstAnd".} proc LLVMConstOr*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstOr".} proc LLVMConstXor*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstXor".} proc LLVMConstICmp*(Predicate: LLVMIntPredicate, LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstICmp".} proc LLVMConstFCmp*(Predicate: LLVMRealPredicate, LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstFCmp".} proc LLVMConstShl*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstShl".} proc LLVMConstLShr*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstLShr".} proc LLVMConstAShr*(LHSConstant: LLVMValueRef, RHSConstant: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstAShr".} proc LLVMConstGEP*(ConstantVal: LLVMValueRef, ConstantIndices: pLLVMValueRef, NumIndices: dword): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstGEP".} proc LLVMConstInBoundsGEP*(ConstantVal: LLVMValueRef, ConstantIndices: pLLVMValueRef, NumIndices: dword): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstInBoundsGEP".} proc LLVMConstTrunc*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstTrunc".} proc LLVMConstSExt*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstSExt".} proc LLVMConstZExt*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstZExt".} proc LLVMConstFPTrunc*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstFPTrunc".} proc LLVMConstFPExt*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstFPExt".} proc LLVMConstUIToFP*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstUIToFP".} proc LLVMConstSIToFP*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstSIToFP".} proc LLVMConstFPToUI*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstFPToUI".} proc LLVMConstFPToSI*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstFPToSI".} proc LLVMConstPtrToInt*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstPtrToInt".} proc LLVMConstIntToPtr*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstIntToPtr".} proc LLVMConstBitCast*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstBitCast".} proc LLVMConstZExtOrBitCast*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstZExtOrBitCast".} proc LLVMConstSExtOrBitCast*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstSExtOrBitCast".} proc LLVMConstTruncOrBitCast*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstTruncOrBitCast".} proc LLVMConstPointerCast*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstPointerCast".} proc LLVMConstIntCast*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef, isSigned: dword): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstIntCast".} proc LLVMConstFPCast*(ConstantVal: LLVMValueRef, ToType: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstFPCast".} proc LLVMConstSelect*(ConstantCondition: LLVMValueRef, ConstantIfTrue: LLVMValueRef, ConstantIfFalse: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstSelect".} proc LLVMConstExtractElement*(VectorConstant: LLVMValueRef, IndexConstant: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstExtractElement".} proc LLVMConstInsertElement*(VectorConstant: LLVMValueRef, ElementValueConstant: LLVMValueRef, IndexConstant: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstInsertElement".} proc LLVMConstShuffleVector*(VectorAConstant: LLVMValueRef, VectorBConstant: LLVMValueRef, MaskConstant: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstShuffleVector".} proc LLVMConstExtractValue*(AggConstant: LLVMValueRef, IdxList: pdword, NumIdx: dword): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstExtractValue".} proc LLVMConstInsertValue*(AggConstant: LLVMValueRef, ElementValueConstant: LLVMValueRef, IdxList: pdword, NumIdx: dword): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMConstInsertValue".} proc LLVMConstInlineAsm*(Ty: LLVMTypeRef, AsmString: cstring, Constraints: cstring, HasSideEffects: int32): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMConstInlineAsm".} # Operations on global variables, functions, and aliases (globals) proc LLVMGetGlobalParent*(Global: LLVMValueRef): LLVMModuleRef{.cdecl, dynlib: libname, importc: "LLVMGetGlobalParent".} proc LLVMIsDeclaration*(Global: LLVMValueRef): int32{.cdecl, dynlib: libname, importc: "LLVMIsDeclaration".} proc LLVMGetLinkage*(Global: LLVMValueRef): LLVMLinkage{.cdecl, dynlib: libname, importc: "LLVMGetLinkage".} proc LLVMSetLinkage*(Global: LLVMValueRef, Linkage: LLVMLinkage){.cdecl, dynlib: libname, importc: "LLVMSetLinkage".} proc LLVMGetSection*(Global: LLVMValueRef): cstring{.cdecl, dynlib: libname, importc: "LLVMGetSection".} proc LLVMSetSection*(Global: LLVMValueRef, Section: cstring){.cdecl, dynlib: libname, importc: "LLVMSetSection".} proc LLVMGetVisibility*(Global: LLVMValueRef): LLVMVisibility{.cdecl, dynlib: libname, importc: "LLVMGetVisibility".} proc LLVMSetVisibility*(Global: LLVMValueRef, Viz: LLVMVisibility){.cdecl, dynlib: libname, importc: "LLVMSetVisibility".} proc LLVMGetAlignment*(Global: LLVMValueRef): dword{.cdecl, dynlib: libname, importc: "LLVMGetAlignment".} proc LLVMSetAlignment*(Global: LLVMValueRef, Bytes: dword){.cdecl, dynlib: libname, importc: "LLVMSetAlignment".} # Operations on global variables proc LLVMAddGlobal*(M: LLVMModuleRef, Ty: LLVMTypeRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMAddGlobal".} proc LLVMGetNamedGlobal*(M: LLVMModuleRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetNamedGlobal".} proc LLVMGetFirstGlobal*(M: LLVMModuleRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetFirstGlobal".} proc LLVMGetLastGlobal*(M: LLVMModuleRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetLastGlobal".} proc LLVMGetNextGlobal*(GlobalVar: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetNextGlobal".} proc LLVMGetPreviousGlobal*(GlobalVar: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetPreviousGlobal".} proc LLVMDeleteGlobal*(GlobalVar: LLVMValueRef){.cdecl, dynlib: libname, importc: "LLVMDeleteGlobal".} proc LLVMGetInitializer*(GlobalVar: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetInitializer".} proc LLVMSetInitializer*(GlobalVar: LLVMValueRef, ConstantVal: LLVMValueRef){. cdecl, dynlib: libname, importc: "LLVMSetInitializer".} proc LLVMIsThreadLocal*(GlobalVar: LLVMValueRef): int32{.cdecl, dynlib: libname, importc: "LLVMIsThreadLocal".} proc LLVMSetThreadLocal*(GlobalVar: LLVMValueRef, IsThreadLocal: int32){.cdecl, dynlib: libname, importc: "LLVMSetThreadLocal".} proc LLVMIsGlobalConstant*(GlobalVar: LLVMValueRef): int32{.cdecl, dynlib: libname, importc: "LLVMIsGlobalConstant".} proc LLVMSetGlobalConstant*(GlobalVar: LLVMValueRef, IsConstant: int32){.cdecl, dynlib: libname, importc: "LLVMSetGlobalConstant".} # Operations on aliases proc LLVMAddAlias*(M: LLVMModuleRef, Ty: LLVMTypeRef, Aliasee: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMAddAlias".} # Operations on functions proc LLVMAddFunction*(M: LLVMModuleRef, Name: cstring, FunctionTy: LLVMTypeRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMAddFunction".} proc LLVMGetNamedFunction*(M: LLVMModuleRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMGetNamedFunction".} proc LLVMGetFirstFunction*(M: LLVMModuleRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetFirstFunction".} proc LLVMGetLastFunction*(M: LLVMModuleRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetLastFunction".} proc LLVMGetNextFunction*(Fn: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetNextFunction".} proc LLVMGetPreviousFunction*(Fn: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetPreviousFunction".} proc LLVMDeleteFunction*(Fn: LLVMValueRef){.cdecl, dynlib: libname, importc: "LLVMDeleteFunction".} proc LLVMGetIntrinsicID*(Fn: LLVMValueRef): dword{.cdecl, dynlib: libname, importc: "LLVMGetIntrinsicID".} proc LLVMGetFunctionCallConv*(Fn: LLVMValueRef): dword{.cdecl, dynlib: libname, importc: "LLVMGetFunctionCallConv".} proc LLVMSetFunctionCallConv*(Fn: LLVMValueRef, CC: dword){.cdecl, dynlib: libname, importc: "LLVMSetFunctionCallConv".} proc LLVMGetGC*(Fn: LLVMValueRef): cstring{.cdecl, dynlib: libname, importc: "LLVMGetGC".} proc LLVMSetGC*(Fn: LLVMValueRef, Name: cstring){.cdecl, dynlib: libname, importc: "LLVMSetGC".} proc LLVMAddFunctionAttr*(Fn: LLVMValueRef, PA: LLVMAttribute){.cdecl, dynlib: libname, importc: "LLVMAddFunctionAttr".} proc LLVMGetFunctionAttr*(Fn: LLVMValueRef): LLVMAttribute{.cdecl, dynlib: libname, importc: "LLVMGetFunctionAttr".} proc LLVMRemoveFunctionAttr*(Fn: LLVMValueRef, PA: LLVMAttribute){.cdecl, dynlib: libname, importc: "LLVMRemoveFunctionAttr".} # Operations on parameters proc LLVMCountParams*(Fn: LLVMValueRef): dword{.cdecl, dynlib: libname, importc: "LLVMCountParams".} proc LLVMGetParams*(Fn: LLVMValueRef, Params: pLLVMValueRef){.cdecl, dynlib: libname, importc: "LLVMGetParams".} proc LLVMGetParam*(Fn: LLVMValueRef, Index: dword): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetParam".} proc LLVMGetParamParent*(Inst: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetParamParent".} proc LLVMGetFirstParam*(Fn: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetFirstParam".} proc LLVMGetLastParam*(Fn: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetLastParam".} proc LLVMGetNextParam*(Arg: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetNextParam".} proc LLVMGetPreviousParam*(Arg: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetPreviousParam".} proc LLVMAddAttribute*(Arg: LLVMValueRef, PA: LLVMAttribute){.cdecl, dynlib: libname, importc: "LLVMAddAttribute".} proc LLVMRemoveAttribute*(Arg: LLVMValueRef, PA: LLVMAttribute){.cdecl, dynlib: libname, importc: "LLVMRemoveAttribute".} proc LLVMGetAttribute*(Arg: LLVMValueRef): LLVMAttribute{.cdecl, dynlib: libname, importc: "LLVMGetAttribute".} proc LLVMSetParamAlignment*(Arg: LLVMValueRef, align: dword){.cdecl, dynlib: libname, importc: "LLVMSetParamAlignment".} # Operations on basic blocks proc LLVMBasicBlockAsValue*(BB: LLVMBasicBlockRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBasicBlockAsValue".} proc LLVMValueIsBasicBlock*(Val: LLVMValueRef): int32{.cdecl, dynlib: libname, importc: "LLVMValueIsBasicBlock".} proc LLVMValueAsBasicBlock*(Val: LLVMValueRef): LLVMBasicBlockRef{.cdecl, dynlib: libname, importc: "LLVMValueAsBasicBlock".} proc LLVMGetBasicBlockParent*(BB: LLVMBasicBlockRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetBasicBlockParent".} proc LLVMCountBasicBlocks*(Fn: LLVMValueRef): dword{.cdecl, dynlib: libname, importc: "LLVMCountBasicBlocks".} proc LLVMGetBasicBlocks*(Fn: LLVMValueRef, BasicBlocks: pLLVMBasicBlockRef){. cdecl, dynlib: libname, importc: "LLVMGetBasicBlocks".} proc LLVMGetFirstBasicBlock*(Fn: LLVMValueRef): LLVMBasicBlockRef{.cdecl, dynlib: libname, importc: "LLVMGetFirstBasicBlock".} proc LLVMGetLastBasicBlock*(Fn: LLVMValueRef): LLVMBasicBlockRef{.cdecl, dynlib: libname, importc: "LLVMGetLastBasicBlock".} proc LLVMGetNextBasicBlock*(BB: LLVMBasicBlockRef): LLVMBasicBlockRef{.cdecl, dynlib: libname, importc: "LLVMGetNextBasicBlock".} proc LLVMGetPreviousBasicBlock*(BB: LLVMBasicBlockRef): LLVMBasicBlockRef{. cdecl, dynlib: libname, importc: "LLVMGetPreviousBasicBlock".} proc LLVMGetEntryBasicBlock*(Fn: LLVMValueRef): LLVMBasicBlockRef{.cdecl, dynlib: libname, importc: "LLVMGetEntryBasicBlock".} proc LLVMAppendBasicBlockInContext*(C: LLVMContextRef, Fn: LLVMValueRef, Name: cstring): LLVMBasicBlockRef{.cdecl, dynlib: libname, importc: "LLVMAppendBasicBlockInContext".} proc LLVMInsertBasicBlockInContext*(C: LLVMContextRef, BB: LLVMBasicBlockRef, Name: cstring): LLVMBasicBlockRef{.cdecl, dynlib: libname, importc: "LLVMInsertBasicBlockInContext".} proc LLVMAppendBasicBlock*(Fn: LLVMValueRef, Name: cstring): LLVMBasicBlockRef{. cdecl, dynlib: libname, importc: "LLVMAppendBasicBlock".} proc LLVMInsertBasicBlock*(InsertBeforeBB: LLVMBasicBlockRef, Name: cstring): LLVMBasicBlockRef{. cdecl, dynlib: libname, importc: "LLVMInsertBasicBlock".} proc LLVMDeleteBasicBlock*(BB: LLVMBasicBlockRef){.cdecl, dynlib: libname, importc: "LLVMDeleteBasicBlock".} # Operations on instructions proc LLVMGetInstructionParent*(Inst: LLVMValueRef): LLVMBasicBlockRef{.cdecl, dynlib: libname, importc: "LLVMGetInstructionParent".} proc LLVMGetFirstInstruction*(BB: LLVMBasicBlockRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetFirstInstruction".} proc LLVMGetLastInstruction*(BB: LLVMBasicBlockRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetLastInstruction".} proc LLVMGetNextInstruction*(Inst: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetNextInstruction".} proc LLVMGetPreviousInstruction*(Inst: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMGetPreviousInstruction".} # Operations on call sites proc LLVMSetInstructionCallConv*(Instr: LLVMValueRef, CC: dword){.cdecl, dynlib: libname, importc: "LLVMSetInstructionCallConv".} proc LLVMGetInstructionCallConv*(Instr: LLVMValueRef): dword{.cdecl, dynlib: libname, importc: "LLVMGetInstructionCallConv".} proc LLVMAddInstrAttribute*(Instr: LLVMValueRef, index: dword, para3: LLVMAttribute){.cdecl, dynlib: libname, importc: "LLVMAddInstrAttribute".} proc LLVMRemoveInstrAttribute*(Instr: LLVMValueRef, index: dword, para3: LLVMAttribute){.cdecl, dynlib: libname, importc: "LLVMRemoveInstrAttribute".} proc LLVMSetInstrParamAlignment*(Instr: LLVMValueRef, index: dword, align: dword){. cdecl, dynlib: libname, importc: "LLVMSetInstrParamAlignment".} # Operations on call instructions (only) proc LLVMIsTailCall*(CallInst: LLVMValueRef): int32{.cdecl, dynlib: libname, importc: "LLVMIsTailCall".} proc LLVMSetTailCall*(CallInst: LLVMValueRef, IsTailCall: int32){.cdecl, dynlib: libname, importc: "LLVMSetTailCall".} # Operations on phi nodes proc LLVMAddIncoming*(PhiNode: LLVMValueRef, IncomingValues: pLLVMValueRef, IncomingBlocks: pLLVMBasicBlockRef, Count: dword){.cdecl, dynlib: libname, importc: "LLVMAddIncoming".} proc LLVMCountIncoming*(PhiNode: LLVMValueRef): dword{.cdecl, dynlib: libname, importc: "LLVMCountIncoming".} proc LLVMGetIncomingValue*(PhiNode: LLVMValueRef, Index: dword): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMGetIncomingValue".} proc LLVMGetIncomingBlock*(PhiNode: LLVMValueRef, Index: dword): LLVMBasicBlockRef{. 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 LLVMCreateBuilderInContext*(C: LLVMContextRef): LLVMBuilderRef{.cdecl, dynlib: libname, importc: "LLVMCreateBuilderInContext".} proc LLVMCreateBuilder*(): LLVMBuilderRef{.cdecl, dynlib: libname, importc: "LLVMCreateBuilder".} proc LLVMPositionBuilder*(Builder: LLVMBuilderRef, theBlock: LLVMBasicBlockRef, Instr: LLVMValueRef){.cdecl, dynlib: libname, importc: "LLVMPositionBuilder".} proc LLVMPositionBuilderBefore*(Builder: LLVMBuilderRef, Instr: LLVMValueRef){. cdecl, dynlib: libname, importc: "LLVMPositionBuilderBefore".} proc LLVMPositionBuilderAtEnd*(Builder: LLVMBuilderRef, theBlock: LLVMBasicBlockRef){. cdecl, dynlib: libname, importc: "LLVMPositionBuilderAtEnd".} proc LLVMGetInsertBlock*(Builder: LLVMBuilderRef): LLVMBasicBlockRef{.cdecl, dynlib: libname, importc: "LLVMGetInsertBlock".} proc LLVMClearInsertionPosition*(Builder: LLVMBuilderRef){.cdecl, dynlib: libname, importc: "LLVMClearInsertionPosition".} proc LLVMInsertIntoBuilder*(Builder: LLVMBuilderRef, Instr: LLVMValueRef){. cdecl, dynlib: libname, importc: "LLVMInsertIntoBuilder".} proc LLVMInsertIntoBuilderWithName*(Builder: LLVMBuilderRef, Instr: LLVMValueRef, Name: cstring){.cdecl, dynlib: libname, importc: "LLVMInsertIntoBuilderWithName".} proc LLVMDisposeBuilder*(Builder: LLVMBuilderRef){.cdecl, dynlib: libname, importc: "LLVMDisposeBuilder".} # Terminators proc LLVMBuildRetVoid*(para1: LLVMBuilderRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildRetVoid".} proc LLVMBuildRet*(para1: LLVMBuilderRef, V: LLVMValueRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildRet".} proc LLVMBuildAggregateRet*(para1: LLVMBuilderRef, RetVals: pLLVMValueRef, N: dword): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildAggregateRet".} proc LLVMBuildBr*(para1: LLVMBuilderRef, Dest: LLVMBasicBlockRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildBr".} proc LLVMBuildCondBr*(para1: LLVMBuilderRef, Cond: LLVMValueRef, ThenBranch: LLVMBasicBlockRef, ElseBranch: LLVMBasicBlockRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildCondBr".} proc LLVMBuildSwitch*(para1: LLVMBuilderRef, V: LLVMValueRef, ElseBranch: LLVMBasicBlockRef, NumCases: dword): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildSwitch".} proc LLVMBuildInvoke*(para1: LLVMBuilderRef, Fn: LLVMValueRef, Args: pLLVMValueRef, NumArgs: dword, ThenBranch: LLVMBasicBlockRef, Catch: LLVMBasicBlockRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildInvoke".} proc LLVMBuildUnwind*(para1: LLVMBuilderRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildUnwind".} proc LLVMBuildUnreachable*(para1: LLVMBuilderRef): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildUnreachable".} # Add a case to the switch instruction proc LLVMAddCase*(Switch: LLVMValueRef, OnVal: LLVMValueRef, Dest: LLVMBasicBlockRef){.cdecl, dynlib: libname, importc: "LLVMAddCase".} # Arithmetic proc LLVMBuildAdd*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildAdd".} proc LLVMBuildNSWAdd*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildNSWAdd".} proc LLVMBuildFAdd*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildFAdd".} proc LLVMBuildSub*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildSub".} proc LLVMBuildFSub*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildFSub".} proc LLVMBuildMul*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildMul".} proc LLVMBuildFMul*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildFMul".} proc LLVMBuildUDiv*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildUDiv".} proc LLVMBuildSDiv*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildSDiv".} proc LLVMBuildExactSDiv*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildExactSDiv".} proc LLVMBuildFDiv*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildFDiv".} proc LLVMBuildURem*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildURem".} proc LLVMBuildSRem*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildSRem".} proc LLVMBuildFRem*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildFRem".} proc LLVMBuildShl*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildShl".} proc LLVMBuildLShr*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildLShr".} proc LLVMBuildAShr*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildAShr".} proc LLVMBuildAnd*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildAnd".} proc LLVMBuildOr*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildOr".} proc LLVMBuildXor*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildXor".} proc LLVMBuildNeg*(para1: LLVMBuilderRef, V: LLVMValueRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildNeg".} proc LLVMBuildFNeg*(para1: LLVMBuilderRef, V: LLVMValueRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildFNeg".} proc LLVMBuildNot*(para1: LLVMBuilderRef, V: LLVMValueRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildNot".} # Memory proc LLVMBuildMalloc*(para1: LLVMBuilderRef, Ty: LLVMTypeRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildMalloc".} proc LLVMBuildArrayMalloc*(para1: LLVMBuilderRef, Ty: LLVMTypeRef, Val: LLVMValueRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildArrayMalloc".} proc LLVMBuildAlloca*(para1: LLVMBuilderRef, Ty: LLVMTypeRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildAlloca".} proc LLVMBuildArrayAlloca*(para1: LLVMBuilderRef, Ty: LLVMTypeRef, Val: LLVMValueRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildArrayAlloca".} proc LLVMBuildFree*(para1: LLVMBuilderRef, PointerVal: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildFree".} proc LLVMBuildLoad*(para1: LLVMBuilderRef, PointerVal: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildLoad".} proc LLVMBuildStore*(para1: LLVMBuilderRef, Val: LLVMValueRef, thePtr: LLVMValueRef): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildStore".} proc LLVMBuildGEP*(B: LLVMBuilderRef, Pointer: LLVMValueRef, Indices: pLLVMValueRef, NumIndices: dword, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildGEP".} proc LLVMBuildInBoundsGEP*(B: LLVMBuilderRef, Pointer: LLVMValueRef, Indices: pLLVMValueRef, NumIndices: dword, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildInBoundsGEP".} proc LLVMBuildStructGEP*(B: LLVMBuilderRef, Pointer: LLVMValueRef, Idx: dword, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildStructGEP".} proc LLVMBuildGlobalString*(B: LLVMBuilderRef, Str: cstring, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildGlobalString".} proc LLVMBuildGlobalStringPtr*(B: LLVMBuilderRef, Str: cstring, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildGlobalStringPtr".} # Casts proc LLVMBuildTrunc*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildTrunc".} proc LLVMBuildZExt*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildZExt".} proc LLVMBuildSExt*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildSExt".} proc LLVMBuildFPToUI*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildFPToUI".} proc LLVMBuildFPToSI*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildFPToSI".} proc LLVMBuildUIToFP*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildUIToFP".} proc LLVMBuildSIToFP*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildSIToFP".} proc LLVMBuildFPTrunc*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildFPTrunc".} proc LLVMBuildFPExt*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildFPExt".} proc LLVMBuildPtrToInt*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildPtrToInt".} proc LLVMBuildIntToPtr*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildIntToPtr".} proc LLVMBuildBitCast*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildBitCast".} proc LLVMBuildZExtOrBitCast*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildZExtOrBitCast".} proc LLVMBuildSExtOrBitCast*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildSExtOrBitCast".} proc LLVMBuildTruncOrBitCast*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildTruncOrBitCast".} proc LLVMBuildPointerCast*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildPointerCast".} proc LLVMBuildIntCast*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildIntCast".} proc LLVMBuildFPCast*(para1: LLVMBuilderRef, Val: LLVMValueRef, DestTy: LLVMTypeRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildFPCast".} # Comparisons proc LLVMBuildICmp*(para1: LLVMBuilderRef, Op: LLVMIntPredicate, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildICmp".} proc LLVMBuildFCmp*(para1: LLVMBuilderRef, Op: LLVMRealPredicate, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildFCmp".} # Miscellaneous instructions proc LLVMBuildPhi*(para1: LLVMBuilderRef, Ty: LLVMTypeRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildPhi".} proc LLVMBuildCall*(para1: LLVMBuilderRef, Fn: LLVMValueRef, Args: pLLVMValueRef, NumArgs: dword, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildCall".} proc LLVMBuildSelect*(para1: LLVMBuilderRef, Cond: LLVMValueRef, ThenBranch: LLVMValueRef, ElseBranch: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildSelect".} proc LLVMBuildVAArg*(para1: LLVMBuilderRef, List: LLVMValueRef, Ty: LLVMTypeRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildVAArg".} proc LLVMBuildExtractElement*(para1: LLVMBuilderRef, VecVal: LLVMValueRef, Index: LLVMValueRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildExtractElement".} proc LLVMBuildInsertElement*(para1: LLVMBuilderRef, VecVal: LLVMValueRef, EltVal: LLVMValueRef, Index: LLVMValueRef, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildInsertElement".} proc LLVMBuildShuffleVector*(para1: LLVMBuilderRef, V1: LLVMValueRef, V2: LLVMValueRef, Mask: LLVMValueRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildShuffleVector".} proc LLVMBuildExtractValue*(para1: LLVMBuilderRef, AggVal: LLVMValueRef, Index: dword, Name: cstring): LLVMValueRef{.cdecl, dynlib: libname, importc: "LLVMBuildExtractValue".} proc LLVMBuildInsertValue*(para1: LLVMBuilderRef, AggVal: LLVMValueRef, EltVal: LLVMValueRef, Index: dword, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildInsertValue".} proc LLVMBuildIsNull*(para1: LLVMBuilderRef, Val: LLVMValueRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildIsNull".} proc LLVMBuildIsNotNull*(para1: LLVMBuilderRef, Val: LLVMValueRef, Name: cstring): LLVMValueRef{. cdecl, dynlib: libname, importc: "LLVMBuildIsNotNull".} proc LLVMBuildPtrDiff*(para1: LLVMBuilderRef, LHS: LLVMValueRef, RHS: LLVMValueRef, Name: cstring): LLVMValueRef{.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 LLVMCreateModuleProviderForExistingModule*(M: LLVMModuleRef): LLVMModuleProviderRef{. cdecl, dynlib: libname, importc: "LLVMCreateModuleProviderForExistingModule".} # Destroys the module provider MP as well as the contained module. # * See the destructor llvm::ModuleProvider::~ModuleProvider. # proc LLVMDisposeModuleProvider*(MP: LLVMModuleProviderRef){.cdecl, dynlib: libname, importc: "LLVMDisposeModuleProvider".} #===-- Memory buffers ----------------------------------------------------=== proc LLVMCreateMemoryBufferWithContentsOfFile*(Path: cstring, OutMemBuf: pLLVMMemoryBufferRef, OutMessage: Ppchar): int32{.cdecl, dynlib: libname, importc: "LLVMCreateMemoryBufferWithContentsOfFile".} proc LLVMCreateMemoryBufferWithSTDIN*(OutMemBuf: pLLVMMemoryBufferRef, OutMessage: Ppchar): int32{.cdecl, dynlib: libname, importc: "LLVMCreateMemoryBufferWithSTDIN".} proc LLVMDisposeMemoryBuffer*(MemBuf: LLVMMemoryBufferRef){.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 LLVMCreatePassManager*(): LLVMPassManagerRef{.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 LLVMCreateFunctionPassManager*(MP: LLVMModuleProviderRef): LLVMPassManagerRef{. 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 LLVMRunPassManager*(PM: LLVMPassManagerRef, M: LLVMModuleRef): 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 LLVMInitializeFunctionPassManager*(FPM: LLVMPassManagerRef): 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 LLVMRunFunctionPassManager*(FPM: LLVMPassManagerRef, F: LLVMValueRef): 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 LLVMFinalizeFunctionPassManager*(FPM: LLVMPassManagerRef): 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 LLVMDisposePassManager*(PM: LLVMPassManagerRef){.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 LLVMVerifierFailureAction* = 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. LLVMAbortProcessAction, LLVMPrintMessageAction, LLVMReturnStatusAction proc LLVMVerifyModule*(M: LLVMModuleRef, Action: LLVMVerifierFailureAction, OutMessage: Ppchar): int32{.cdecl, dynlib: libname, importc: "LLVMVerifyModule".} # Verifies that a single function is valid, taking the specified action. Useful # for debugging. proc LLVMVerifyFunction*(Fn: LLVMValueRef, Action: LLVMVerifierFailureAction): int32{. cdecl, dynlib: libname, importc: "LLVMVerifyFunction".} # Open up a ghostview window that displays the CFG of the current function. # Useful for debugging. proc LLVMViewFunctionCFG*(Fn: LLVMValueRef){.cdecl, dynlib: libname, importc: "LLVMViewFunctionCFG".} proc LLVMViewFunctionCFGOnly*(Fn: LLVMValueRef){.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 LLVMParseBitcode*(MemBuf: LLVMMemoryBufferRef, OutModule: pLLVMModuleRef, OutMessage: Ppchar): int32{.cdecl, dynlib: libname, importc: "LLVMParseBitcode".} proc LLVMParseBitcodeInContext*(ContextRef: LLVMContextRef, MemBuf: LLVMMemoryBufferRef, OutModule: pLLVMModuleRef, OutMessage: Ppchar): 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 LLVMGetBitcodeModuleProvider*(MemBuf: LLVMMemoryBufferRef, OutMP: pLLVMModuleProviderRef, OutMessage: Ppchar): int32{.cdecl, dynlib: libname, importc: "LLVMGetBitcodeModuleProvider".} proc LLVMGetBitcodeModuleProviderInContext*(ContextRef: LLVMContextRef, MemBuf: LLVMMemoryBufferRef, OutMP: pLLVMModuleProviderRef, OutMessage: Ppchar): 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 LLVMWriteBitcodeToFileHandle*(M: LLVMModuleRef, Handle: int32): int32{. cdecl, dynlib: libname, importc: "LLVMWriteBitcodeToFileHandle".} # Writes a module to the specified path. Returns 0 on success. proc LLVMWriteBitcodeToFile*(M: LLVMModuleRef, Path: cstring): int32{.cdecl, dynlib: libname, importc: "LLVMWriteBitcodeToFile".} # Target.h const LLVMBigEndian* = 0 LLVMLittleEndian* = 1 type LLVMByteOrdering* = int32 LLVMTargetDataRef* = LLVMOpaqueTargetData LLVMStructLayoutRef* = LLVMStructLayout #===-- Target Data -------------------------------------------------------=== #* Creates target data from a target layout string. # See the constructor llvm::TargetData::TargetData. proc LLVMCreateTargetData*(StringRep: cstring): LLVMTargetDataRef{.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 LLVMAddTargetData*(para1: LLVMTargetDataRef, para2: LLVMPassManagerRef){. 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 LLVMCopyStringRepOfTargetData*(para1: LLVMTargetDataRef): cstring{.cdecl, dynlib: libname, importc: "LLVMCopyStringRepOfTargetData".} #* Returns the byte order of a target, either LLVMBigEndian or # LLVMLittleEndian. # See the method llvm::TargetData::isLittleEndian. proc LLVMByteOrder*(para1: LLVMTargetDataRef): LLVMByteOrdering{.cdecl, dynlib: libname, importc: "LLVMByteOrder".} #* Returns the pointer size in bytes for a target. # See the method llvm::TargetData::getPointerSize. proc LLVMPointerSize*(para1: LLVMTargetDataRef): dword{.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 LLVMIntPtrType*(para1: LLVMTargetDataRef): LLVMTypeRef{.cdecl, dynlib: libname, importc: "LLVMIntPtrType".} #* Computes the size of a type in bytes for a target. # See the method llvm::TargetData::getTypeSizeInBits. proc LLVMSizeOfTypeInBits*(para1: LLVMTargetDataRef, para2: LLVMTypeRef): qword{. cdecl, dynlib: libname, importc: "LLVMSizeOfTypeInBits".} #* Computes the storage size of a type in bytes for a target. # See the method llvm::TargetData::getTypeStoreSize. proc LLVMStoreSizeOfType*(para1: LLVMTargetDataRef, para2: LLVMTypeRef): qword{. cdecl, dynlib: libname, importc: "LLVMStoreSizeOfType".} #* Computes the ABI size of a type in bytes for a target. # See the method llvm::TargetData::getTypeAllocSize. proc LLVMABISizeOfType*(para1: LLVMTargetDataRef, para2: LLVMTypeRef): qword{. cdecl, dynlib: libname, importc: "LLVMABISizeOfType".} #* Computes the ABI alignment of a type in bytes for a target. # See the method llvm::TargetData::getTypeABISize. proc LLVMABIAlignmentOfType*(para1: LLVMTargetDataRef, para2: LLVMTypeRef): dword{. 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 LLVMCallFrameAlignmentOfType*(para1: LLVMTargetDataRef, para2: LLVMTypeRef): dword{. cdecl, dynlib: libname, importc: "LLVMCallFrameAlignmentOfType".} #* Computes the preferred alignment of a type in bytes for a target. # See the method llvm::TargetData::getTypeABISize. proc LLVMPreferredAlignmentOfType*(para1: LLVMTargetDataRef, para2: LLVMTypeRef): dword{. 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 LLVMPreferredAlignmentOfGlobal*(para1: LLVMTargetDataRef, GlobalVar: LLVMValueRef): dword{.cdecl, dynlib: libname, importc: "LLVMPreferredAlignmentOfGlobal".} #* Computes the structure element that contains the byte offset for a target. # See the method llvm::StructLayout::getElementContainingOffset. proc LLVMElementAtOffset*(para1: LLVMTargetDataRef, StructTy: LLVMTypeRef, Offset: qword): dword{.cdecl, dynlib: libname, importc: "LLVMElementAtOffset".} #* Computes the byte offset of the indexed struct element for a target. # See the method llvm::StructLayout::getElementContainingOffset. proc LLVMOffsetOfElement*(para1: LLVMTargetDataRef, StructTy: LLVMTypeRef, Element: dword): qword{.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 LLVMInvalidateStructLayout*(para1: LLVMTargetDataRef, StructTy: LLVMTypeRef){. cdecl, dynlib: libname, importc: "LLVMInvalidateStructLayout".} #* Deallocates a TargetData. # See the destructor llvm::TargetData::~TargetData. proc LLVMDisposeTargetData*(para1: LLVMTargetDataRef){.cdecl, dynlib: libname, importc: "LLVMDisposeTargetData".} # ExecutionEngine.h proc LLVMLinkInJIT*(){.cdecl, dynlib: libname, importc: "LLVMLinkInJIT".} proc LLVMLinkInInterpreter*(){.cdecl, dynlib: libname, importc: "LLVMLinkInInterpreter".} type LLVMGenericValueRef* = LLVMOpaqueGenericValue LLVMExecutionEngineRef* = LLVMOpaqueExecutionEngine #===-- Operations on generic values --------------------------------------=== proc LLVMCreateGenericValueOfInt*(Ty: LLVMTypeRef, N: qword, IsSigned: int32): LLVMGenericValueRef{. cdecl, dynlib: libname, importc: "LLVMCreateGenericValueOfInt".} proc LLVMCreateGenericValueOfPointer*(P: pointer): LLVMGenericValueRef{.cdecl, dynlib: libname, importc: "LLVMCreateGenericValueOfPointer".} proc LLVMCreateGenericValueOfFloat*(Ty: LLVMTypeRef, N: float64): LLVMGenericValueRef{. cdecl, dynlib: libname, importc: "LLVMCreateGenericValueOfFloat".} proc LLVMGenericValueIntWidth*(GenValRef: LLVMGenericValueRef): dword{.cdecl, dynlib: libname, importc: "LLVMGenericValueIntWidth".} proc LLVMGenericValueToInt*(GenVal: LLVMGenericValueRef, IsSigned: int32): qword{. cdecl, dynlib: libname, importc: "LLVMGenericValueToInt".} proc LLVMGenericValueToPointer*(GenVal: LLVMGenericValueRef): pointer{.cdecl, dynlib: libname, importc: "LLVMGenericValueToPointer".} proc LLVMGenericValueToFloat*(TyRef: LLVMTypeRef, GenVal: LLVMGenericValueRef): float64{. cdecl, dynlib: libname, importc: "LLVMGenericValueToFloat".} proc LLVMDisposeGenericValue*(GenVal: LLVMGenericValueRef){.cdecl, dynlib: libname, importc: "LLVMDisposeGenericValue".} #===-- Operations on execution engines -----------------------------------=== proc LLVMCreateExecutionEngine*(OutEE: pLLVMExecutionEngineRef, MP: LLVMModuleProviderRef, OutError: Ppchar): int32{. cdecl, dynlib: libname, importc: "LLVMCreateExecutionEngine".} proc LLVMCreateInterpreter*(OutInterp: pLLVMExecutionEngineRef, MP: LLVMModuleProviderRef, OutError: Ppchar): int32{. cdecl, dynlib: libname, importc: "LLVMCreateInterpreter".} proc LLVMCreateJITCompiler*(OutJIT: pLLVMExecutionEngineRef, MP: LLVMModuleProviderRef, OptLevel: dword, OutError: Ppchar): int32{.cdecl, dynlib: libname, importc: "LLVMCreateJITCompiler".} proc LLVMDisposeExecutionEngine*(EE: LLVMExecutionEngineRef){.cdecl, dynlib: libname, importc: "LLVMDisposeExecutionEngine".} proc LLVMRunStaticConstructors*(EE: LLVMExecutionEngineRef){.cdecl, dynlib: libname, importc: "LLVMRunStaticConstructors".} proc LLVMRunStaticDestructors*(EE: LLVMExecutionEngineRef){.cdecl, dynlib: libname, importc: "LLVMRunStaticDestructors".} # Const before declarator ignored # Const before declarator ignored proc LLVMRunFunctionAsMain*(EE: LLVMExecutionEngineRef, F: LLVMValueRef, ArgC: dword, ArgV: Ppchar, EnvP: Ppchar): int32{. cdecl, dynlib: libname, importc: "LLVMRunFunctionAsMain".} proc LLVMRunFunction*(EE: LLVMExecutionEngineRef, F: LLVMValueRef, NumArgs: dword, Args: pLLVMGenericValueRef): LLVMGenericValueRef{. cdecl, dynlib: libname, importc: "LLVMRunFunction".} proc LLVMFreeMachineCodeForFunction*(EE: LLVMExecutionEngineRef, F: LLVMValueRef){. cdecl, dynlib: libname, importc: "LLVMFreeMachineCodeForFunction".} proc LLVMAddModuleProvider*(EE: LLVMExecutionEngineRef, MP: LLVMModuleProviderRef){.cdecl, dynlib: libname, importc: "LLVMAddModuleProvider".} proc LLVMRemoveModuleProvider*(EE: LLVMExecutionEngineRef, MP: LLVMModuleProviderRef, OutMod: pLLVMModuleRef, OutError: Ppchar): int32{. cdecl, dynlib: libname, importc: "LLVMRemoveModuleProvider".} proc LLVMFindFunction*(EE: LLVMExecutionEngineRef, Name: cstring, OutFn: pLLVMValueRef): int32{.cdecl, dynlib: libname, importc: "LLVMFindFunction".} proc LLVMGetExecutionEngineTargetData*(EE: LLVMExecutionEngineRef): LLVMTargetDataRef{. cdecl, dynlib: libname, importc: "LLVMGetExecutionEngineTargetData".} proc LLVMAddGlobalMapping*(EE: LLVMExecutionEngineRef, Global: LLVMValueRef, theAddr: pointer){.cdecl, dynlib: libname, importc: "LLVMAddGlobalMapping".} proc LLVMGetPointerToGlobal*(EE: LLVMExecutionEngineRef, Global: LLVMValueRef): pointer{. cdecl, dynlib: libname, importc: "LLVMGetPointerToGlobal".} # LinkTimeOptimizer.h #/ This provides a dummy type for pointers to the LTO object. type llvm_lto_t* = pointer #/ This provides a C-visible enumerator to manage status codes. #/ This should map exactly onto the C++ enumerator LTOStatus. # Added C-specific error codes llvm_lto_status* = enum LLVM_LTO_UNKNOWN, LLVM_LTO_OPT_SUCCESS, LLVM_LTO_READ_SUCCESS, LLVM_LTO_READ_FAILURE, LLVM_LTO_WRITE_FAILURE, LLVM_LTO_NO_TARGET, LLVM_LTO_NO_WORK, LLVM_LTO_MODULE_MERGE_FAILURE, LLVM_LTO_ASM_FAILURE, LLVM_LTO_NULL_OBJECT llvm_lto_status_t* = llvm_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 llvm_create_optimizer*(): llvm_lto_t{.cdecl, dynlib: libname, importc: "llvm_create_optimizer".} proc llvm_destroy_optimizer*(lto: llvm_lto_t){.cdecl, dynlib: libname, importc: "llvm_destroy_optimizer".} proc llvm_read_object_file*(lto: llvm_lto_t, input_filename: cstring): llvm_lto_status_t{. cdecl, dynlib: libname, importc: "llvm_read_object_file".} proc llvm_optimize_modules*(lto: llvm_lto_t, output_filename: cstring): llvm_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 LTO_SYMBOL_ALIGNMENT_MASK = 0x0000001F, LTO_SYMBOL_PERMISSIONS_MASK = 0x000000E0, LTO_SYMBOL_PERMISSIONS_CODE = 0x000000A0, LTO_SYMBOL_PERMISSIONS_DATA = 0x000000C0, LTO_SYMBOL_PERMISSIONS_RODATA = 0x00000080, LTO_SYMBOL_DEFINITION_MASK = 0x00000700, LTO_SYMBOL_DEFINITION_REGULAR = 0x00000100, LTO_SYMBOL_DEFINITION_TENTATIVE = 0x00000200, LTO_SYMBOL_DEFINITION_WEAK = 0x00000300, LTO_SYMBOL_DEFINITION_UNDEFINED = 0x00000400, LTO_SYMBOL_DEFINITION_WEAKUNDEF = 0x00000500, LTO_SYMBOL_SCOPE_MASK = 0x00003800, LTO_SYMBOL_SCOPE_INTERNAL = 0x00000800, LTO_SYMBOL_SCOPE_HIDDEN = 0x00001000, LTO_SYMBOL_SCOPE_PROTECTED = 0x00002000, LTO_SYMBOL_SCOPE_DEFAULT = 0x00001800 lto_debug_model* = enum LTO_DEBUG_MODEL_NONE = 0, LTO_DEBUG_MODEL_DWARF = 1 lto_codegen_model* = enum #* opaque reference to a loaded object module LTO_CODEGEN_PIC_MODEL_STATIC = 0, LTO_CODEGEN_PIC_MODEL_DYNAMIC = 1, LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC = 2 lto_module_t* = LTOModule #* opaque reference to a code generator lto_code_gen_t* = LTOCodeGenerator #* # * Returns a printable string. # 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: size_t): 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: size_t, 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: size_t): 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): dword{.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: dword): 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: dword): 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".} # implementation