path: root/llvm/llvm_orig.nim

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