const 
  libname* = "llvm.dll"               #Setup as you need

type
  OpaqueContext {.pure.} = object
  OpaqueModule {.pure.} = object
  TOpaqueType {.pure.} = object
  OpaqueTypeHandle {.pure.} = object
  OpaqueValue {.pure.} = object
  OpaqueBasicBlock {.pure.} = object
  OpaqueBuilder {.pure.} = object
  OpaqueModuleProvider {.pure.} = object
  OpaqueMemoryBuffer {.pure.} = object
  OpaquePassManager {.pure.} = object
  OpaqueUseIterator {.pure.} = object

  ContextRef* = OpaqueContext
  ModuleRef* = OpaqueModule  
  TypeRef* = TOpaqueType  
  TypeHandleRef* = OpaqueTypeHandle
  ValueRef* = OpaqueValue
  BasicBlockRef* = OpaqueBasicBlock
  BuilderRef* = OpaqueBuilder 
  ModuleProviderRef* = OpaqueModuleProvider   
  MemoryBufferRef* = OpaqueMemoryBuffer   
  PassManagerRef* = OpaquePassManager 
  UseIteratorRef* = OpaqueUseIterator
  Attribute* = enum 
    ZExtAttribute = 1 shl 0, SExtAttribute = 1 shl 1, 
    NoReturnAttribute = 1 shl 2, InRegAttribute = 1 shl 3, 
    StructRetAttribute = 1 shl 4, NoUnwindAttribute = 1 shl 5, 
    NoAliasAttribute = 1 shl 6, ByValAttribute = 1 shl 7, 
    NestAttribute = 1 shl 8, ReadNoneAttribute = 1 shl 9, 
    ReadOnlyAttribute = 1 shl 10, NoInlineAttribute = 1 shl 11, 
    AlwaysInlineAttribute = 1 shl 12, OptimizeForSizeAttribute = 1 shl 13, 
    StackProtectAttribute = 1 shl 14, StackProtectReqAttribute = 1 shl 15, 
    NoCaptureAttribute = 1 shl 21, NoRedZoneAttribute = 1 shl 22, 
    NoImplicitFloatAttribute = 1 shl 23, NakedAttribute = 1 shl 24, 
    InlineHintAttribute = 1 shl 25
  Opcode* = enum
    opcRet = 1, opcBr = 2, opcSwitch = 3, opcInvoke = 4, opcUnwind = 5,
    opcUnreachable = 6, 
    opcAdd = 7, opcFAdd = 8, opcSub = 9, opcFSub = 10, opcMul = 11,
    opcFMul = 12, opcUDiv = 13, 
    opcSDiv = 14, opcFDiv = 15, opcURem = 16, opcSRem = 17, opcFRem = 18,
    opcShl = 19,
    opcLShr = 20, opcAShr = 21, opcAnd = 22, opcOr = 23, opcXor = 24,
    opcMalloc = 25, opcFree = 26, opcAlloca = 27, 
    opcLoad = 28, opcStore = 29,
    opcGetElementPtr = 30, opcTrunk = 31, opcZExt = 32, opcSExt = 33, 
    opcFPToUI = 34, opcFPToSI = 35, opcUIToFP = 36, opcSIToFP = 37,
    opcFPTrunc = 38, opcFPExt = 39, opcPtrToInt = 40, opcIntToPtr = 41,
    opcBitCast = 42, opcICmp = 43, 
    opcFCmp = 44, opcPHI = 45, opcCall = 46, opcSelect = 47, opcVAArg = 50, 
    opcExtractElement = 51, opcInsertElement = 52, opcShuffleVector = 53, 
    opcExtractValue = 54, opcInsertValue = 55
  TypeKind* = enum 
    VoidTypeKind, FloatTypeKind, DoubleTypeKind, X86_FP80TypeKind, 
    FP128TypeKind, PPC_FP128TypeKind, LabelTypeKind, IntegerTypeKind, 
    FunctionTypeKind, StructTypeKind, ArrayTypeKind, PointerTypeKind, 
    OpaqueTypeKind, VectorTypeKind, MetadataTypeKind
  TLinkage* = enum
    ExternalLinkage,            ## Externally visible function 
    AvailableExternallyLinkage, ## Keep one copy of function when linking (inline) 
    LinkOnceAnyLinkage, ## Same, but only replaced by something equivalent.
    LinkOnceODRLinkage, ## Keep one copy of function when linking (weak)
    WeakAnyLinkage,     ## Same, but only replaced by something equivalent.
    WeakODRLinkage,     ## Special purpose, only applies to global arrays
    AppendingLinkage,   ## Rename collisions when linking (static functions)
    InternalLinkage,    ## 
    PrivateLinkage,     ## Like Internal, but omit from symbol table
    DLLImportLinkage,   ## Function to be imported from DLL
    DLLExportLinkage,   ## Function to be accessible from DLL 
    ExternalWeakLinkage, ## ExternalWeak linkage description 
    GhostLinkage,       ## Stand-in functions for streaming fns from bitcode 
    CommonLinkage,      ## Tentative definitions  
    LinkerPrivateLinkage ## Like Private, but linker removes.
  TVisibility* = enum
    DefaultVisibility,
    HiddenVisibility,
    ProtectedVisibility
  TCallConv* = enum          
    CCallConv = 0, FastCallConv = 8, ColdCallConv = 9, X86StdcallCallConv = 64, 
    X86FastcallCallConv = 65
  IntPredicate* = enum       
    IntEQ = 32, IntNE, IntUGT, IntUGE, IntULT, IntULE, IntSGT, IntSGE, IntSLT, 
    IntSLE
  RealPredicate* = enum       
    RealPredicateFalse, RealOEQ, RealOGT, RealOGE, RealOLT, RealOLE, RealONE, 
    RealORD, RealUNO, RealUEQ, RealUGT, RealUGE, RealULT, RealULE, RealUNE, 
    RealPredicateTrue

#===-- Error handling ----------------------------------------------------=== 

proc DisposeMessage*(Message: cstring){.cdecl, dynlib: libname, 
                                        importc: "LLVMDisposeMessage".}
  
#===-- Modules -----------------------------------------------------------=== 
# Create and destroy contexts.  
proc ContextCreate*(): ContextRef{.cdecl, dynlib: libname, 
                                   importc: "LLVMContextCreate".}
proc GetGlobalContext*(): ContextRef{.cdecl, dynlib: libname, 
                                      importc: "LLVMGetGlobalContext".}
proc ContextDispose*(C: ContextRef){.cdecl, dynlib: libname, 
                                     importc: "LLVMContextDispose".}
  # Create and destroy modules.  
  # See llvm::Module::Module.  
proc ModuleCreateWithName*(ModuleID: cstring): ModuleRef{.cdecl, 
    dynlib: libname, importc: "LLVMModuleCreateWithName".}
proc ModuleCreateWithNameInContext*(ModuleID: cstring, C: ContextRef): ModuleRef{.
    cdecl, dynlib: libname, importc: "LLVMModuleCreateWithNameInContext".}
  # See llvm::Module::~Module.  
proc DisposeModule*(M: ModuleRef){.cdecl, dynlib: libname, 
                                   importc: "LLVMDisposeModule".}
  # Data layout. See Module::getDataLayout.  
proc GetDataLayout*(M: ModuleRef): cstring{.cdecl, dynlib: libname, 
    importc: "LLVMGetDataLayout".}
proc SetDataLayout*(M: ModuleRef, Triple: cstring){.cdecl, dynlib: libname, 
    importc: "LLVMSetDataLayout".}
  # Target triple. See Module::getTargetTriple.  
proc GetTarget*(M: ModuleRef): cstring{.cdecl, dynlib: libname, 
                                        importc: "LLVMGetTarget".}
proc SetTarget*(M: ModuleRef, Triple: cstring){.cdecl, dynlib: libname, 
    importc: "LLVMSetTarget".}
  # See Module::addTypeName.  
proc AddTypeName*(M: ModuleRef, Name: cstring, Ty: TypeRef): int32{.cdecl, 
    dynlib: libname, importc: "LLVMAddTypeName".}
proc DeleteTypeName*(M: ModuleRef, Name: cstring){.cdecl, dynlib: libname, 
    importc: "LLVMDeleteTypeName".}
proc GetTypeByName*(M: ModuleRef, Name: cstring): TypeRef{.cdecl, 
    dynlib: libname, importc: "LLVMGetTypeByName".}
  # See Module::dump.  
proc DumpModule*(M: ModuleRef){.cdecl, dynlib: libname, 
                                importc: "LLVMDumpModule".}
  #===-- Types -------------------------------------------------------------=== 
  # LLVM types conform to the following hierarchy:
  # * 
  # *   types:
  # *     integer type
  # *     real type
  # *     function type
  # *     sequence types:
  # *       array type
  # *       pointer type
  # *       vector type
  # *     void type
  # *     label type
  # *     opaque type
  #  
  # See llvm::LLVMTypeKind::getTypeID.  
proc GetTypeKind*(Ty: TypeRef): TypeKind{.cdecl, dynlib: libname, 
    importc: "LLVMGetTypeKind".}
  # See llvm::LLVMType::getContext.  
proc GetTypeContext*(Ty: TypeRef): ContextRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetTypeContext".}
  # Operations on integer types  
proc Int1TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMInt1TypeInContext".}
proc Int8TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMInt8TypeInContext".}
proc Int16TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMInt16TypeInContext".}
proc Int32TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMInt32TypeInContext".}
proc Int64TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMInt64TypeInContext".}
proc IntTypeInContext*(C: ContextRef, NumBits: int32): TypeRef{.cdecl, 
    dynlib: libname, importc: "LLVMIntTypeInContext".}
proc Int1Type*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMInt1Type".}
proc Int8Type*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMInt8Type".}
proc Int16Type*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMInt16Type".}
proc Int32Type*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMInt32Type".}
proc Int64Type*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMInt64Type".}
proc IntType*(NumBits: int32): TypeRef{.cdecl, dynlib: libname, 
                                        importc: "LLVMIntType".}
proc GetIntTypeWidth*(IntegerTy: TypeRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMGetIntTypeWidth".}
  # Operations on real types  
proc FloatTypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMFloatTypeInContext".}
proc DoubleTypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMDoubleTypeInContext".}
proc X86FP80TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMX86FP80TypeInContext".}
proc FP128TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMFP128TypeInContext".}
proc PPCFP128TypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMPPCFP128TypeInContext".}
proc FloatType*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMFloatType".}
proc DoubleType*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMDoubleType".}
proc X86FP80Type*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMX86FP80Type".}
proc FP128Type*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMFP128Type".}
proc PPCFP128Type*(): TypeRef{.cdecl, dynlib: libname, 
                               importc: "LLVMPPCFP128Type".}
  # Operations on function types  
proc FunctionType*(ReturnType: TypeRef, ParamTypes: ptr TypeRef,
                   ParamCount: int32, IsVarArg: int32): TypeRef {.
    cdecl, dynlib: libname, importc: "LLVMFunctionType".}
proc IsFunctionVarArg*(FunctionTy: TypeRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMIsFunctionVarArg".}
proc GetReturnType*(FunctionTy: TypeRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetReturnType".}
proc CountParamTypes*(FunctionTy: TypeRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMCountParamTypes".}
proc GetParamTypes*(FunctionTy: TypeRef, Dest: ptr TypeRef){.cdecl, 
    dynlib: libname, importc: "LLVMGetParamTypes".}
  # Operations on struct types  
proc StructTypeInContext*(C: ContextRef, ElementTypes: ptr TypeRef, 
                          ElementCount: int32, isPacked: int32): TypeRef{.cdecl, 
    dynlib: libname, importc: "LLVMStructTypeInContext".}
proc StructType*(ElementTypes: ptr TypeRef, ElementCount: int32, isPacked: int32): TypeRef{.
    cdecl, dynlib: libname, importc: "LLVMStructType".}
proc CountStructElementTypes*(StructTy: TypeRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMCountStructElementTypes".}
proc GetStructElementTypes*(StructTy: TypeRef, Dest: ptr TypeRef){.cdecl, 
    dynlib: libname, importc: "LLVMGetStructElementTypes".}
proc IsPackedStruct*(StructTy: TypeRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMIsPackedStruct".}
  # Operations on array, pointer, and vector types (sequence types)  
proc ArrayType*(ElementType: TypeRef, ElementCount: int32): TypeRef{.cdecl, 
    dynlib: libname, importc: "LLVMArrayType".}
proc PointerType*(ElementType: TypeRef, AddressSpace: int32): TypeRef{.cdecl, 
    dynlib: libname, importc: "LLVMPointerType".}
proc VectorType*(ElementType: TypeRef, ElementCount: int32): TypeRef{.cdecl, 
    dynlib: libname, importc: "LLVMVectorType".}
proc GetElementType*(Ty: TypeRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetElementType".}
proc GetArrayLength*(ArrayTy: TypeRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMGetArrayLength".}
proc GetPointerAddressSpace*(PointerTy: TypeRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMGetPointerAddressSpace".}
proc GetVectorSize*(VectorTy: TypeRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMGetVectorSize".}
  # Operations on other types  
proc VoidTypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMVoidTypeInContext".}
proc LabelTypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMLabelTypeInContext".}
proc OpaqueTypeInContext*(C: ContextRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMOpaqueTypeInContext".}
proc VoidType*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMVoidType".}
proc LabelType*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMLabelType".}
proc OpaqueType*(): TypeRef{.cdecl, dynlib: libname, importc: "LLVMOpaqueType".}
  # Operations on type handles  
proc CreateTypeHandle*(PotentiallyAbstractTy: TypeRef): TypeHandleRef{.cdecl, 
    dynlib: libname, importc: "LLVMCreateTypeHandle".}
proc RefineType*(AbstractTy: TypeRef, ConcreteTy: TypeRef){.cdecl, 
    dynlib: libname, importc: "LLVMRefineType".}
proc ResolveTypeHandle*(TypeHandle: TypeHandleRef): TypeRef{.cdecl, 
    dynlib: libname, importc: "LLVMResolveTypeHandle".}
proc DisposeTypeHandle*(TypeHandle: TypeHandleRef){.cdecl, dynlib: libname, 
    importc: "LLVMDisposeTypeHandle".}
  # Operations on all values  
proc TypeOf*(Val: ValueRef): TypeRef{.cdecl, dynlib: libname, 
                                      importc: "LLVMTypeOf".}
proc GetValueName*(Val: ValueRef): cstring{.cdecl, dynlib: libname, 
    importc: "LLVMGetValueName".}
proc SetValueName*(Val: ValueRef, Name: cstring){.cdecl, dynlib: libname, 
    importc: "LLVMSetValueName".}
proc DumpValue*(Val: ValueRef){.cdecl, dynlib: libname, importc: "LLVMDumpValue".}
proc ReplaceAllUsesWith*(OldVal: ValueRef, NewVal: ValueRef){.cdecl, 
    dynlib: libname, importc: "LLVMReplaceAllUsesWith".}
  # Conversion functions. Return the input value if it is an instance of the
  #   specified class, otherwise NULL. See llvm::dyn_cast_or_null<>.  
proc IsAArgument*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAArgument".}
proc IsABasicBlock*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsABasicBlock".}
proc IsAInlineAsm*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAInlineAsm".}
proc IsAUser*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
                                        importc: "LLVMIsAUser".}
proc IsAConstant*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAConstant".}
proc IsAConstantAggregateZero*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAConstantAggregateZero".}
proc IsAConstantArray*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAConstantArray".}
proc IsAConstantExpr*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAConstantExpr".}
proc IsAConstantFP*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAConstantFP".}
proc IsAConstantInt*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAConstantInt".}
proc IsAConstantPointerNull*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAConstantPointerNull".}
proc IsAConstantStruct*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAConstantStruct".}
proc IsAConstantVector*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAConstantVector".}
proc IsAGlobalValue*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAGlobalValue".}
proc IsAFunction*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAFunction".}
proc IsAGlobalAlias*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAGlobalAlias".}
proc IsAGlobalVariable*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAGlobalVariable".}
proc IsAUndefValue*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAUndefValue".}
proc IsAInstruction*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAInstruction".}
proc IsABinaryOperator*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsABinaryOperator".}
proc IsACallInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsACallInst".}
proc IsAIntrinsicInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAIntrinsicInst".}
proc IsADbgInfoIntrinsic*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsADbgInfoIntrinsic".}
proc IsADbgDeclareInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsADbgDeclareInst".}
proc IsADbgFuncStartInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsADbgFuncStartInst".}
proc IsADbgRegionEndInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsADbgRegionEndInst".}
proc IsADbgRegionStartInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsADbgRegionStartInst".}
proc IsADbgStopPointInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsADbgStopPointInst".}
proc IsAEHSelectorInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAEHSelectorInst".}
proc IsAMemIntrinsic*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAMemIntrinsic".}
proc IsAMemCpyInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAMemCpyInst".}
proc IsAMemMoveInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAMemMoveInst".}
proc IsAMemSetInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAMemSetInst".}
proc IsACmpInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsACmpInst".}
proc IsAFCmpInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAFCmpInst".}
proc IsAICmpInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAICmpInst".}
proc IsAExtractElementInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAExtractElementInst".}
proc IsAGetElementPtrInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAGetElementPtrInst".}
proc IsAInsertElementInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAInsertElementInst".}
proc IsAInsertValueInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAInsertValueInst".}
proc IsAPHINode*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAPHINode".}
proc IsASelectInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsASelectInst".}
proc IsAShuffleVectorInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAShuffleVectorInst".}
proc IsAStoreInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAStoreInst".}
proc IsATerminatorInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsATerminatorInst".}
proc IsABranchInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsABranchInst".}
proc IsAInvokeInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAInvokeInst".}
proc IsAReturnInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAReturnInst".}
proc IsASwitchInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsASwitchInst".}
proc IsAUnreachableInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAUnreachableInst".}
proc IsAUnwindInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAUnwindInst".}
proc IsAUnaryInstruction*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAUnaryInstruction".}
proc IsAAllocationInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAAllocationInst".}
proc IsAAllocaInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAAllocaInst".}
proc IsACastInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsACastInst".}
proc IsABitCastInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsABitCastInst".}
proc IsAFPExtInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAFPExtInst".}
proc IsAFPToSIInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAFPToSIInst".}
proc IsAFPToUIInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAFPToUIInst".}
proc IsAFPTruncInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAFPTruncInst".}
proc IsAIntToPtrInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAIntToPtrInst".}
proc IsAPtrToIntInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAPtrToIntInst".}
proc IsASExtInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsASExtInst".}
proc IsASIToFPInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsASIToFPInst".}
proc IsATruncInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsATruncInst".}
proc IsAUIToFPInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAUIToFPInst".}
proc IsAZExtInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAZExtInst".}
proc IsAExtractValueInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAExtractValueInst".}
proc IsAFreeInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAFreeInst".}
proc IsALoadInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsALoadInst".}
proc IsAVAArgInst*(Val: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMIsAVAArgInst".}
  # Operations on Uses  
proc GetFirstUse*(Val: ValueRef): UseIteratorRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetFirstUse".}
proc GetNextUse*(U: UseIteratorRef): UseIteratorRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetNextUse".}
proc GetUser*(U: UseIteratorRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetUser".}
proc GetUsedValue*(U: UseIteratorRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetUsedValue".}
  # Operations on Users  
proc GetOperand*(Val: ValueRef, Index: int32): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetOperand".}
  # Operations on constants of any type  
proc ConstNull*(Ty: TypeRef): ValueRef{.cdecl, dynlib: libname, 
                                        importc: "LLVMConstNull".}
  # all zeroes  
proc ConstAllOnes*(Ty: TypeRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMConstAllOnes".}
  # only for int/vector  
proc GetUndef*(Ty: TypeRef): ValueRef{.cdecl, dynlib: libname, 
                                       importc: "LLVMGetUndef".}
proc IsConstant*(Val: ValueRef): int32{.cdecl, dynlib: libname, 
                                        importc: "LLVMIsConstant".}
proc IsNull*(Val: ValueRef): int32{.cdecl, dynlib: libname, 
                                    importc: "LLVMIsNull".}
proc IsUndef*(Val: ValueRef): int32{.cdecl, dynlib: libname, 
                                     importc: "LLVMIsUndef".}
proc ConstPointerNull*(Ty: TypeRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMConstPointerNull".}
  # Operations on scalar constants  
proc ConstInt*(IntTy: TypeRef, N: int64, SignExtend: int32): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstInt".}
proc ConstIntOfString*(IntTy: TypeRef, Text: cstring, Radix: byte): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMConstIntOfString".}
proc ConstIntOfStringAndSize*(IntTy: TypeRef, Text: cstring, SLen: int32, 
                              Radix: byte): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMConstIntOfStringAndSize".}
proc ConstReal*(RealTy: TypeRef, N: float64): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMConstReal".}
proc ConstRealOfString*(RealTy: TypeRef, Text: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstRealOfString".}
proc ConstRealOfStringAndSize*(RealTy: TypeRef, Text: cstring, SLen: int32): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMConstRealOfStringAndSize".}
proc ConstIntGetZExtValue*(ConstantVal: ValueRef): int64{.cdecl, 
    dynlib: libname, importc: "LLVMConstIntGetZExtValue".}
proc ConstIntGetSExtValue*(ConstantVal: ValueRef): int64{.cdecl, 
    dynlib: libname, importc: "LLVMConstIntGetSExtValue".}
  # Operations on composite constants  
proc ConstStringInContext*(C: ContextRef, Str: cstring, len: int32, 
                           DontNullTerminate: int32): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstStringInContext".}
proc ConstStructInContext*(C: ContextRef, ConstantVals: ptr ValueRef,
                           Count: int32, 
                           isPacked: int32): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMConstStructInContext".}
proc ConstString*(Str: cstring, len: int32, DontNullTerminate: int32): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMConstString".}
proc ConstArray*(ElementTy: TypeRef, ConstantVals: ptr ValueRef, len: int32): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMConstArray".}
proc ConstStruct*(ConstantVals: ptr ValueRef, Count: int32, isPacked: int32): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMConstStruct".}
proc ConstVector*(ScalarConstantVals: ptr ValueRef, Size: int32): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstVector".}
  # Constant expressions  
proc GetConstOpcode*(ConstantVal: ValueRef): Opcode{.cdecl, dynlib: libname, 
    importc: "LLVMGetConstOpcode".}
proc AlignOf*(Ty: TypeRef): ValueRef{.cdecl, dynlib: libname, 
                                      importc: "LLVMAlignOf".}
proc SizeOf*(Ty: TypeRef): ValueRef{.cdecl, dynlib: libname, 
                                     importc: "LLVMSizeOf".}
proc ConstNeg*(ConstantVal: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMConstNeg".}
proc ConstFNeg*(ConstantVal: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMConstFNeg".}
proc ConstNot*(ConstantVal: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMConstNot".}
proc ConstAdd*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstAdd".}
proc ConstNSWAdd*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMConstNSWAdd".}
proc ConstFAdd*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstFAdd".}
proc ConstSub*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstSub".}
proc ConstFSub*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstFSub".}
proc ConstMul*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstMul".}
proc ConstFMul*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstFMul".}
proc ConstUDiv*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstUDiv".}
proc ConstSDiv*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstSDiv".}
proc ConstExactSDiv*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMConstExactSDiv".}
proc ConstFDiv*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstFDiv".}
proc ConstURem*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstURem".}
proc ConstSRem*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstSRem".}
proc ConstFRem*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstFRem".}
proc ConstAnd*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstAnd".}
proc ConstOr*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstOr".}
proc ConstXor*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstXor".}
proc ConstICmp*(Predicate: IntPredicate, LHSConstant: ValueRef, 
                RHSConstant: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMConstICmp".}
proc ConstFCmp*(Predicate: RealPredicate, LHSConstant: ValueRef, 
                RHSConstant: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMConstFCmp".}
proc ConstShl*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstShl".}
proc ConstLShr*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstLShr".}
proc ConstAShr*(LHSConstant: ValueRef, RHSConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstAShr".}
proc ConstGEP*(ConstantVal: ValueRef, ConstantIndices: ptr ValueRef, 
               NumIndices: int32): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMConstGEP".}
proc ConstInBoundsGEP*(ConstantVal: ValueRef, ConstantIndices: ptr ValueRef, 
                       NumIndices: int32): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMConstInBoundsGEP".}
proc ConstTrunc*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstTrunc".}
proc ConstSExt*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstSExt".}
proc ConstZExt*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstZExt".}
proc ConstFPTrunc*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstFPTrunc".}
proc ConstFPExt*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstFPExt".}
proc ConstUIToFP*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstUIToFP".}
proc ConstSIToFP*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstSIToFP".}
proc ConstFPToUI*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstFPToUI".}
proc ConstFPToSI*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstFPToSI".}
proc ConstPtrToInt*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstPtrToInt".}
proc ConstIntToPtr*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstIntToPtr".}
proc ConstBitCast*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstBitCast".}
proc ConstZExtOrBitCast*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMConstZExtOrBitCast".}
proc ConstSExtOrBitCast*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMConstSExtOrBitCast".}
proc ConstTruncOrBitCast*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMConstTruncOrBitCast".}
proc ConstPointerCast*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstPointerCast".}
proc ConstIntCast*(ConstantVal: ValueRef, ToType: TypeRef, isSigned: int32): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMConstIntCast".}
proc ConstFPCast*(ConstantVal: ValueRef, ToType: TypeRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstFPCast".}
proc ConstSelect*(ConstantCondition: ValueRef, ConstantIfTrue: ValueRef, 
                  ConstantIfFalse: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMConstSelect".}
proc ConstExtractElement*(VectorConstant: ValueRef, IndexConstant: ValueRef): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMConstExtractElement".}
proc ConstInsertElement*(VectorConstant: ValueRef, 
                         ElementValueConstant: ValueRef, IndexConstant: ValueRef): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMConstInsertElement".}
proc ConstShuffleVector*(VectorAConstant: ValueRef, VectorBConstant: ValueRef, 
                         MaskConstant: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstShuffleVector".}
proc ConstExtractValue*(AggConstant: ValueRef, IdxList: ptr int32, NumIdx: int32): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMConstExtractValue".}
proc ConstInsertValue*(AggConstant: ValueRef, ElementValueConstant: ValueRef, 
                       IdxList: ptr int32, NumIdx: int32): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMConstInsertValue".}
proc ConstInlineAsm*(Ty: TypeRef, AsmString: cstring, Constraints: cstring, 
                     HasSideEffects: int32): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMConstInlineAsm".}
  # Operations on global variables, functions, and aliases (globals)  
proc GetGlobalParent*(Global: ValueRef): ModuleRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetGlobalParent".}
proc IsDeclaration*(Global: ValueRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMIsDeclaration".}
proc GetLinkage*(Global: ValueRef): TLinkage{.cdecl, dynlib: libname, 
    importc: "LLVMGetLinkage".}
proc SetLinkage*(Global: ValueRef, Linkage: TLinkage){.cdecl, dynlib: libname, 
    importc: "LLVMSetLinkage".}
proc GetSection*(Global: ValueRef): cstring{.cdecl, dynlib: libname, 
    importc: "LLVMGetSection".}
proc SetSection*(Global: ValueRef, Section: cstring){.cdecl, dynlib: libname, 
    importc: "LLVMSetSection".}
proc GetVisibility*(Global: ValueRef): TVisibility{.cdecl, dynlib: libname, 
    importc: "LLVMGetVisibility".}
proc SetVisibility*(Global: ValueRef, Viz: TVisibility){.cdecl, dynlib: libname, 
    importc: "LLVMSetVisibility".}
proc GetAlignment*(Global: ValueRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMGetAlignment".}
proc SetAlignment*(Global: ValueRef, Bytes: int32){.cdecl, dynlib: libname, 
    importc: "LLVMSetAlignment".}
  # Operations on global variables  
proc AddGlobal*(M: ModuleRef, Ty: TypeRef, Name: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMAddGlobal".}
proc GetNamedGlobal*(M: ModuleRef, Name: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMGetNamedGlobal".}
proc GetFirstGlobal*(M: ModuleRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetFirstGlobal".}
proc GetLastGlobal*(M: ModuleRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetLastGlobal".}
proc GetNextGlobal*(GlobalVar: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetNextGlobal".}
proc GetPreviousGlobal*(GlobalVar: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetPreviousGlobal".}
proc DeleteGlobal*(GlobalVar: ValueRef){.cdecl, dynlib: libname, 
    importc: "LLVMDeleteGlobal".}
proc GetInitializer*(GlobalVar: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetInitializer".}
proc SetInitializer*(GlobalVar: ValueRef, ConstantVal: ValueRef){.cdecl, 
    dynlib: libname, importc: "LLVMSetInitializer".}
proc IsThreadLocal*(GlobalVar: ValueRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMIsThreadLocal".}
proc SetThreadLocal*(GlobalVar: ValueRef, IsThreadLocal: int32){.cdecl, 
    dynlib: libname, importc: "LLVMSetThreadLocal".}
proc IsGlobalConstant*(GlobalVar: ValueRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMIsGlobalConstant".}
proc SetGlobalConstant*(GlobalVar: ValueRef, IsConstant: int32){.cdecl, 
    dynlib: libname, importc: "LLVMSetGlobalConstant".}
  # Operations on aliases  
proc AddAlias*(M: ModuleRef, Ty: TypeRef, Aliasee: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMAddAlias".}
  # Operations on functions  
proc AddFunction*(M: ModuleRef, Name: cstring, FunctionTy: TypeRef): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMAddFunction".}
proc GetNamedFunction*(M: ModuleRef, Name: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMGetNamedFunction".}
proc GetFirstFunction*(M: ModuleRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetFirstFunction".}
proc GetLastFunction*(M: ModuleRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetLastFunction".}
proc GetNextFunction*(Fn: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetNextFunction".}
proc GetPreviousFunction*(Fn: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetPreviousFunction".}
proc DeleteFunction*(Fn: ValueRef){.cdecl, dynlib: libname, 
                                    importc: "LLVMDeleteFunction".}
proc GetIntrinsicID*(Fn: ValueRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMGetIntrinsicID".}
proc GetFunctionCallConv*(Fn: ValueRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMGetFunctionCallConv".}
proc SetFunctionCallConv*(Fn: ValueRef, CC: int32){.cdecl, dynlib: libname, 
    importc: "LLVMSetFunctionCallConv".}
proc GetGC*(Fn: ValueRef): cstring{.cdecl, dynlib: libname, importc: "LLVMGetGC".}
proc SetGC*(Fn: ValueRef, Name: cstring){.cdecl, dynlib: libname, 
    importc: "LLVMSetGC".}
proc AddFunctionAttr*(Fn: ValueRef, PA: Attribute){.cdecl, dynlib: libname, 
    importc: "LLVMAddFunctionAttr".}
proc GetFunctionAttr*(Fn: ValueRef): Attribute{.cdecl, dynlib: libname, 
    importc: "LLVMGetFunctionAttr".}
proc RemoveFunctionAttr*(Fn: ValueRef, PA: Attribute){.cdecl, dynlib: libname, 
    importc: "LLVMRemoveFunctionAttr".}
  # Operations on parameters  
proc CountParams*(Fn: ValueRef): int32{.cdecl, dynlib: libname, 
                                        importc: "LLVMCountParams".}
proc GetParams*(Fn: ValueRef, Params: ptr ValueRef){.cdecl, dynlib: libname, 
    importc: "LLVMGetParams".}
proc GetParam*(Fn: ValueRef, Index: int32): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetParam".}
proc GetParamParent*(Inst: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetParamParent".}
proc GetFirstParam*(Fn: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetFirstParam".}
proc GetLastParam*(Fn: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetLastParam".}
proc GetNextParam*(Arg: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetNextParam".}
proc GetPreviousParam*(Arg: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetPreviousParam".}
proc AddAttribute*(Arg: ValueRef, PA: Attribute){.cdecl, dynlib: libname, 
    importc: "LLVMAddAttribute".}
proc RemoveAttribute*(Arg: ValueRef, PA: Attribute){.cdecl, dynlib: libname, 
    importc: "LLVMRemoveAttribute".}
proc GetAttribute*(Arg: ValueRef): Attribute{.cdecl, dynlib: libname, 
    importc: "LLVMGetAttribute".}
proc SetParamAlignment*(Arg: ValueRef, align: int32){.cdecl, dynlib: libname, 
    importc: "LLVMSetParamAlignment".}
  # Operations on basic blocks  
proc BasicBlockAsValue*(BB: BasicBlockRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBasicBlockAsValue".}
proc ValueIsBasicBlock*(Val: ValueRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMValueIsBasicBlock".}
proc ValueAsBasicBlock*(Val: ValueRef): BasicBlockRef{.cdecl, dynlib: libname, 
    importc: "LLVMValueAsBasicBlock".}
proc GetBasicBlockParent*(BB: BasicBlockRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetBasicBlockParent".}
proc CountBasicBlocks*(Fn: ValueRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMCountBasicBlocks".}
proc GetBasicBlocks*(Fn: ValueRef, BasicBlocks: ptr BasicBlockRef){.cdecl, 
    dynlib: libname, importc: "LLVMGetBasicBlocks".}
proc GetFirstBasicBlock*(Fn: ValueRef): BasicBlockRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetFirstBasicBlock".}
proc GetLastBasicBlock*(Fn: ValueRef): BasicBlockRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetLastBasicBlock".}
proc GetNextBasicBlock*(BB: BasicBlockRef): BasicBlockRef{.cdecl, 
    dynlib: libname, importc: "LLVMGetNextBasicBlock".}
proc GetPreviousBasicBlock*(BB: BasicBlockRef): BasicBlockRef{.cdecl, 
    dynlib: libname, importc: "LLVMGetPreviousBasicBlock".}
proc GetEntryBasicBlock*(Fn: ValueRef): BasicBlockRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetEntryBasicBlock".}
proc AppendBasicBlockInContext*(C: ContextRef, Fn: ValueRef, Name: cstring): BasicBlockRef{.
    cdecl, dynlib: libname, importc: "LLVMAppendBasicBlockInContext".}
proc InsertBasicBlockInContext*(C: ContextRef, BB: BasicBlockRef, Name: cstring): BasicBlockRef{.
    cdecl, dynlib: libname, importc: "LLVMInsertBasicBlockInContext".}
proc AppendBasicBlock*(Fn: ValueRef, Name: cstring): BasicBlockRef{.cdecl, 
    dynlib: libname, importc: "LLVMAppendBasicBlock".}
proc InsertBasicBlock*(InsertBeforeBB: BasicBlockRef, Name: cstring): BasicBlockRef{.
    cdecl, dynlib: libname, importc: "LLVMInsertBasicBlock".}
proc DeleteBasicBlock*(BB: BasicBlockRef){.cdecl, dynlib: libname, 
    importc: "LLVMDeleteBasicBlock".}
  # Operations on instructions  
proc GetInstructionParent*(Inst: ValueRef): BasicBlockRef{.cdecl, 
    dynlib: libname, importc: "LLVMGetInstructionParent".}
proc GetFirstInstruction*(BB: BasicBlockRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetFirstInstruction".}
proc GetLastInstruction*(BB: BasicBlockRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetLastInstruction".}
proc GetNextInstruction*(Inst: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetNextInstruction".}
proc GetPreviousInstruction*(Inst: ValueRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMGetPreviousInstruction".}
  # Operations on call sites  
proc SetInstructionCallConv*(Instr: ValueRef, CC: int32){.cdecl, 
    dynlib: libname, importc: "LLVMSetInstructionCallConv".}
proc GetInstructionCallConv*(Instr: ValueRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMGetInstructionCallConv".}
proc AddInstrAttribute*(Instr: ValueRef, index: int32, para3: Attribute){.cdecl, 
    dynlib: libname, importc: "LLVMAddInstrAttribute".}
proc RemoveInstrAttribute*(Instr: ValueRef, index: int32, para3: Attribute){.
    cdecl, dynlib: libname, importc: "LLVMRemoveInstrAttribute".}
proc SetInstrParamAlignment*(Instr: ValueRef, index: int32, align: int32){.
    cdecl, dynlib: libname, importc: "LLVMSetInstrParamAlignment".}
  # Operations on call instructions (only)  
proc IsTailCall*(CallInst: ValueRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMIsTailCall".}
proc SetTailCall*(CallInst: ValueRef, IsTailCall: int32){.cdecl, 
    dynlib: libname, importc: "LLVMSetTailCall".}
  # Operations on phi nodes  
proc AddIncoming*(PhiNode: ValueRef, IncomingValues: ptr ValueRef, 
                  IncomingBlocks: ptr BasicBlockRef, Count: int32){.cdecl, 
    dynlib: libname, importc: "LLVMAddIncoming".}
proc CountIncoming*(PhiNode: ValueRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMCountIncoming".}
proc GetIncomingValue*(PhiNode: ValueRef, Index: int32): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMGetIncomingValue".}
proc GetIncomingBlock*(PhiNode: ValueRef, Index: int32): BasicBlockRef{.cdecl, 
    dynlib: libname, importc: "LLVMGetIncomingBlock".}
  #===-- Instruction builders ----------------------------------------------=== 
  # An instruction builder represents a point within a basic block, and is the
  # * exclusive means of building instructions using the C interface.
  #  
proc CreateBuilderInContext*(C: ContextRef): BuilderRef{.cdecl, dynlib: libname, 
    importc: "LLVMCreateBuilderInContext".}
proc CreateBuilder*(): BuilderRef{.cdecl, dynlib: libname, 
                                   importc: "LLVMCreateBuilder".}
proc PositionBuilder*(Builder: BuilderRef, theBlock: BasicBlockRef, 
                      Instr: ValueRef){.cdecl, dynlib: libname, 
                                        importc: "LLVMPositionBuilder".}
proc PositionBuilderBefore*(Builder: BuilderRef, Instr: ValueRef){.cdecl, 
    dynlib: libname, importc: "LLVMPositionBuilderBefore".}
proc PositionBuilderAtEnd*(Builder: BuilderRef, theBlock: BasicBlockRef){.cdecl, 
    dynlib: libname, importc: "LLVMPositionBuilderAtEnd".}
proc GetInsertBlock*(Builder: BuilderRef): BasicBlockRef{.cdecl, 
    dynlib: libname, importc: "LLVMGetInsertBlock".}
proc ClearInsertionPosition*(Builder: BuilderRef){.cdecl, dynlib: libname, 
    importc: "LLVMClearInsertionPosition".}
proc InsertIntoBuilder*(Builder: BuilderRef, Instr: ValueRef){.cdecl, 
    dynlib: libname, importc: "LLVMInsertIntoBuilder".}
proc InsertIntoBuilderWithName*(Builder: BuilderRef, Instr: ValueRef, 
                                Name: cstring){.cdecl, dynlib: libname, 
    importc: "LLVMInsertIntoBuilderWithName".}
proc DisposeBuilder*(Builder: BuilderRef){.cdecl, dynlib: libname, 
    importc: "LLVMDisposeBuilder".}
  # Terminators  
proc BuildRetVoid*(para1: BuilderRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildRetVoid".}
proc BuildRet*(para1: BuilderRef, V: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMBuildRet".}
proc BuildAggregateRet*(para1: BuilderRef, RetVals: ptr ValueRef, N: int32): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildAggregateRet".}
proc BuildBr*(para1: BuilderRef, Dest: BasicBlockRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMBuildBr".}
proc BuildCondBr*(para1: BuilderRef, Cond: ValueRef, ThenBranch: BasicBlockRef, 
                  ElseBranch: BasicBlockRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildCondBr".}
proc BuildSwitch*(para1: BuilderRef, V: ValueRef, ElseBranch: BasicBlockRef, 
                  NumCases: int32): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildSwitch".}
proc BuildInvoke*(para1: BuilderRef, Fn: ValueRef, Args: ptr ValueRef, 
                  NumArgs: int32, ThenBranch: BasicBlockRef, 
                  Catch: BasicBlockRef, Name: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMBuildInvoke".}
proc BuildUnwind*(para1: BuilderRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildUnwind".}
proc BuildUnreachable*(para1: BuilderRef): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildUnreachable".}
  # Add a case to the switch instruction  
proc AddCase*(Switch: ValueRef, OnVal: ValueRef, Dest: BasicBlockRef){.cdecl, 
    dynlib: libname, importc: "LLVMAddCase".}
  # Arithmetic  
proc BuildAdd*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildAdd".}
proc BuildNSWAdd*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildNSWAdd".}
proc BuildFAdd*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildFAdd".}
proc BuildSub*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildSub".}
proc BuildFSub*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildFSub".}
proc BuildMul*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildMul".}
proc BuildFMul*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildFMul".}
proc BuildUDiv*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildUDiv".}
proc BuildSDiv*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildSDiv".}
proc BuildExactSDiv*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, 
                     Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildExactSDiv".}
proc BuildFDiv*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildFDiv".}
proc BuildURem*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildURem".}
proc BuildSRem*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildSRem".}
proc BuildFRem*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildFRem".}
proc BuildShl*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildShl".}
proc BuildLShr*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildLShr".}
proc BuildAShr*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildAShr".}
proc BuildAnd*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildAnd".}
proc BuildOr*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildOr".}
proc BuildXor*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildXor".}
proc BuildNeg*(para1: BuilderRef, V: ValueRef, Name: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMBuildNeg".}
proc BuildFNeg*(para1: BuilderRef, V: ValueRef, Name: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMBuildFNeg".}
proc BuildNot*(para1: BuilderRef, V: ValueRef, Name: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMBuildNot".}
  # Memory  
proc BuildMalloc*(para1: BuilderRef, Ty: TypeRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildMalloc".}
proc BuildArrayMalloc*(para1: BuilderRef, Ty: TypeRef, Val: ValueRef, 
                       Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildArrayMalloc".}
proc BuildAlloca*(para1: BuilderRef, Ty: TypeRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildAlloca".}
proc BuildArrayAlloca*(para1: BuilderRef, Ty: TypeRef, Val: ValueRef, 
                       Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildArrayAlloca".}
proc BuildFree*(para1: BuilderRef, PointerVal: ValueRef): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMBuildFree".}
proc BuildLoad*(para1: BuilderRef, PointerVal: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildLoad".}
proc BuildStore*(para1: BuilderRef, Val: ValueRef, thePtr: ValueRef): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildStore".}
proc BuildGEP*(B: BuilderRef, Pointer: ValueRef, Indices: ptr ValueRef, 
               NumIndices: int32, Name: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMBuildGEP".}
proc BuildInBoundsGEP*(B: BuilderRef, Pointer: ValueRef, Indices: ptr ValueRef, 
                       NumIndices: int32, Name: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMBuildInBoundsGEP".}
proc BuildStructGEP*(B: BuilderRef, Pointer: ValueRef, Idx: int32, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildStructGEP".}
proc BuildGlobalString*(B: BuilderRef, Str: cstring, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildGlobalString".}
proc BuildGlobalStringPtr*(B: BuilderRef, Str: cstring, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildGlobalStringPtr".}
  # Casts  
proc BuildTrunc*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                 Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildTrunc".}
proc BuildZExt*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildZExt".}
proc BuildSExt*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildSExt".}
proc BuildFPToUI*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                  Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildFPToUI".}
proc BuildFPToSI*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                  Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildFPToSI".}
proc BuildUIToFP*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                  Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildUIToFP".}
proc BuildSIToFP*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                  Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildSIToFP".}
proc BuildFPTrunc*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                   Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildFPTrunc".}
proc BuildFPExt*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                 Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildFPExt".}
proc BuildPtrToInt*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                    Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildPtrToInt".}
proc BuildIntToPtr*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                    Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildIntToPtr".}
proc BuildBitCast*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                   Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildBitCast".}
proc BuildZExtOrBitCast*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                         Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildZExtOrBitCast".}
proc BuildSExtOrBitCast*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                         Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildSExtOrBitCast".}
proc BuildTruncOrBitCast*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                          Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildTruncOrBitCast".}
proc BuildPointerCast*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                       Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildPointerCast".}
proc BuildIntCast*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                   Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildIntCast".}
proc BuildFPCast*(para1: BuilderRef, Val: ValueRef, DestTy: TypeRef, 
                  Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildFPCast".}
  # Comparisons  
proc BuildICmp*(para1: BuilderRef, Op: IntPredicate, LHS: ValueRef, 
                RHS: ValueRef, Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildICmp".}
proc BuildFCmp*(para1: BuilderRef, Op: RealPredicate, LHS: ValueRef, 
                RHS: ValueRef, Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildFCmp".}
  # Miscellaneous instructions  
proc BuildPhi*(para1: BuilderRef, Ty: TypeRef, Name: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMBuildPhi".}
proc BuildCall*(para1: BuilderRef, Fn: ValueRef, Args: ptr ValueRef, 
                NumArgs: int32, Name: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMBuildCall".}
proc BuildSelect*(para1: BuilderRef, Cond: ValueRef, ThenBranch: ValueRef, 
                  ElseBranch: ValueRef, Name: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMBuildSelect".}
proc BuildVAArg*(para1: BuilderRef, List: ValueRef, Ty: TypeRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildVAArg".}
proc BuildExtractElement*(para1: BuilderRef, VecVal: ValueRef, Index: ValueRef, 
                          Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildExtractElement".}
proc BuildInsertElement*(para1: BuilderRef, VecVal: ValueRef, EltVal: ValueRef, 
                         Index: ValueRef, Name: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMBuildInsertElement".}
proc BuildShuffleVector*(para1: BuilderRef, V1: ValueRef, V2: ValueRef, 
                         Mask: ValueRef, Name: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMBuildShuffleVector".}
proc BuildExtractValue*(para1: BuilderRef, AggVal: ValueRef, Index: int32, 
                        Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildExtractValue".}
proc BuildInsertValue*(para1: BuilderRef, AggVal: ValueRef, EltVal: ValueRef, 
                       Index: int32, Name: cstring): ValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMBuildInsertValue".}
proc BuildIsNull*(para1: BuilderRef, Val: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildIsNull".}
proc BuildIsNotNull*(para1: BuilderRef, Val: ValueRef, Name: cstring): ValueRef{.
    cdecl, dynlib: libname, importc: "LLVMBuildIsNotNull".}
proc BuildPtrDiff*(para1: BuilderRef, LHS: ValueRef, RHS: ValueRef, 
                   Name: cstring): ValueRef{.cdecl, dynlib: libname, 
    importc: "LLVMBuildPtrDiff".}
  #===-- Module providers --------------------------------------------------=== 
  # Encapsulates the module M in a module provider, taking ownership of the
  # module.
  # See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
  #  
proc CreateModuleProviderForExistingModule*(M: ModuleRef): ModuleProviderRef{.
    cdecl, dynlib: libname, importc: "LLVMCreateModuleProviderForExistingModule".}
  # Destroys the module provider MP as well as the contained module.
  # See the destructor llvm::ModuleProvider::~ModuleProvider.
  #  
proc DisposeModuleProvider*(MP: ModuleProviderRef){.cdecl, dynlib: libname, 
    importc: "LLVMDisposeModuleProvider".}
  #===-- Memory buffers ----------------------------------------------------=== 
proc CreateMemoryBufferWithContentsOfFile*(Path: cstring, 
    OutMemBuf: ptr MemoryBufferRef, OutMessage: var cstring): int32{.cdecl, 
    dynlib: libname, importc: "LLVMCreateMemoryBufferWithContentsOfFile".}
proc CreateMemoryBufferWithSTDIN*(OutMemBuf: ptr MemoryBufferRef, 
                                  OutMessage: var cstring): int32{.cdecl, 
    dynlib: libname, importc: "LLVMCreateMemoryBufferWithSTDIN".}
proc DisposeMemoryBuffer*(MemBuf: MemoryBufferRef){.cdecl, dynlib: libname, 
    importc: "LLVMDisposeMemoryBuffer".}
  #===-- Pass Managers -----------------------------------------------------=== 
  # Constructs a new whole-module pass pipeline. This type of pipeline is
  #    suitable for link-time optimization and whole-module transformations.
  #    See llvm::PassManager::PassManager.  
proc CreatePassManager*(): PassManagerRef{.cdecl, dynlib: libname, 
    importc: "LLVMCreatePassManager".}
  #    Constructs a new function-by-function pass pipeline over the module
  #    provider. It does not take ownership of the module provider. This type of
  #    pipeline is suitable for code generation and JIT compilation tasks.
  #    See llvm::FunctionPassManager::FunctionPassManager.  
proc CreateFunctionPassManager*(MP: ModuleProviderRef): PassManagerRef{.cdecl, 
    dynlib: libname, importc: "LLVMCreateFunctionPassManager".}
  # Initializes, executes on the provided module, and finalizes all of the
  #    passes scheduled in the pass manager. Returns 1 if any of the passes
  #    modified the module, 0 otherwise. See llvm::PassManager::run(Module&).  
proc RunPassManager*(PM: PassManagerRef, M: ModuleRef): int32{.cdecl, 
    dynlib: libname, importc: "LLVMRunPassManager".}
  # Initializes all of the function passes scheduled in the function pass
  #    manager. Returns 1 if any of the passes modified the module, 0 otherwise.
  #    See llvm::FunctionPassManager::doInitialization.  
proc InitializeFunctionPassManager*(FPM: PassManagerRef): int32{.cdecl, 
    dynlib: libname, importc: "LLVMInitializeFunctionPassManager".}
  # Executes all of the function passes scheduled in the function pass manager
  # on the provided function. Returns 1 if any of the passes modified the
  # function, false otherwise.
  # See llvm::FunctionPassManager::run(Function&).  
proc RunFunctionPassManager*(FPM: PassManagerRef, F: ValueRef): int32{.cdecl, 
    dynlib: libname, importc: "LLVMRunFunctionPassManager".}
  # Finalizes all of the function passes scheduled in in the function pass
  #    manager. Returns 1 if any of the passes modified the module, 0 otherwise.
  #    See llvm::FunctionPassManager::doFinalization.  
proc FinalizeFunctionPassManager*(FPM: PassManagerRef): int32{.cdecl, 
    dynlib: libname, importc: "LLVMFinalizeFunctionPassManager".}
  # Frees the memory of a pass pipeline. For function pipelines, does not free
  #    the module provider.
  #    See llvm::PassManagerBase::~PassManagerBase.  
proc DisposePassManager*(PM: PassManagerRef){.cdecl, dynlib: libname, 
    importc: "LLVMDisposePassManager".}
  # Analysis.h  
  # verifier will print to stderr and abort()  
  # verifier will print to stderr and return 1  
  # verifier will just return 1  
type 
  VerifierFailureAction* = enum  # Verifies that a module is valid, taking the specified action if not.
                                 #   Optionally returns a human-readable description of any invalid constructs.
                                 #   OutMessage must be disposed with LLVMDisposeMessage.  
    AbortProcessAction, PrintMessageAction, ReturnStatusAction

proc VerifyModule*(M: ModuleRef, Action: VerifierFailureAction, 
                   OutMessage: var cstring): int32{.cdecl, dynlib: libname, 
    importc: "LLVMVerifyModule".}
  # Verifies that a single function is valid, taking the specified action. Useful
  #   for debugging.  
proc VerifyFunction*(Fn: ValueRef, Action: VerifierFailureAction): int32{.cdecl, 
    dynlib: libname, importc: "LLVMVerifyFunction".}
  # Open up a ghostview window that displays the CFG of the current function.
  #   Useful for debugging.  
proc ViewFunctionCFG*(Fn: ValueRef){.cdecl, dynlib: libname, 
                                     importc: "LLVMViewFunctionCFG".}
proc ViewFunctionCFGOnly*(Fn: ValueRef){.cdecl, dynlib: libname, 
    importc: "LLVMViewFunctionCFGOnly".}
  # BitReader.h  
  # Builds a module from the bitcode in the specified memory buffer, returning a
  #   reference to the module via the OutModule parameter. Returns 0 on success.
  #   Optionally returns a human-readable error message via OutMessage.  
proc ParseBitcode*(MemBuf: MemoryBufferRef, OutModule: var ModuleRef, 
                   OutMessage: var cstring): int32{.cdecl, dynlib: libname, 
    importc: "LLVMParseBitcode".}
proc ParseBitcodeInContext*(ContextRef: ContextRef, MemBuf: MemoryBufferRef, 
                            OutModule: var ModuleRef, OutMessage: var cstring): int32{.
    cdecl, dynlib: libname, importc: "LLVMParseBitcodeInContext".}
  # Reads a module from the specified path, returning via the OutMP parameter
  #   a module provider which performs lazy deserialization. Returns 0 on success.
  #   Optionally returns a human-readable error message via OutMessage.  
proc GetBitcodeModuleProvider*(MemBuf: MemoryBufferRef, 
                               OutMP: var ModuleProviderRef,
                               OutMessage: var cstring): int32{.
    cdecl, dynlib: libname, importc: "LLVMGetBitcodeModuleProvider".}
proc GetBitcodeModuleProviderInContext*(ContextRef: ContextRef, 
                                        MemBuf: MemoryBufferRef, 
                                        OutMP: var ModuleProviderRef, 
                                        OutMessage: var cstring): int32{.cdecl, 
    dynlib: libname, importc: "LLVMGetBitcodeModuleProviderInContext".}
  # BitWriter.h  
  #===-- Operations on modules ---------------------------------------------=== 
  # Writes a module to an open file descriptor. Returns 0 on success.
  #   Closes the Handle. Use dup first if this is not what you want.  
proc WriteBitcodeToFileHandle*(M: ModuleRef, Handle: int32): int32{.cdecl, 
    dynlib: libname, importc: "LLVMWriteBitcodeToFileHandle".}
  # Writes a module to the specified path. Returns 0 on success.  
proc WriteBitcodeToFile*(M: ModuleRef, Path: cstring): int32{.cdecl, 
    dynlib: libname, importc: "LLVMWriteBitcodeToFile".}
  # Target.h  
const 
  BigEndian* = 0
  LittleEndian* = 1

type 
  ByteOrdering* = int32
  OpaqueTargetData {.pure} = object
  StructLayout {.pure} = object
  TargetDataRef* = ref OpaqueTargetData
  StructLayoutRef* = ref StructLayout
  
  
#===-- Target Data -------------------------------------------------------=== 
# Creates target data from a target layout string.
# See the constructor llvm::TargetData::TargetData.  

proc CreateTargetData*(StringRep: cstring): TargetDataRef{.cdecl, 
    dynlib: libname, importc: "LLVMCreateTargetData".}
  # Adds target data information to a pass manager. This does not take ownership
  #    of the target data.
  #    See the method llvm::PassManagerBase::add.  
proc AddTargetData*(para1: TargetDataRef, para2: PassManagerRef){.cdecl, 
    dynlib: libname, importc: "LLVMAddTargetData".}
  # Converts target data to a target layout string. The string must be disposed
  #    with LLVMDisposeMessage.
  #    See the constructor llvm::TargetData::TargetData.  
proc CopyStringRepOfTargetData*(para1: TargetDataRef): cstring{.cdecl, 
    dynlib: libname, importc: "LLVMCopyStringRepOfTargetData".}
  # Returns the byte order of a target, either LLVMBigEndian or
  #    LLVMLittleEndian.
  #    See the method llvm::TargetData::isLittleEndian.  
proc ByteOrder*(para1: TargetDataRef): ByteOrdering{.cdecl, dynlib: libname, 
    importc: "LLVMByteOrder".}
  # Returns the pointer size in bytes for a target.
  #    See the method llvm::TargetData::getPointerSize.  
proc PointerSize*(para1: TargetDataRef): int32{.cdecl, dynlib: libname, 
    importc: "LLVMPointerSize".}
  # Returns the integer type that is the same size as a pointer on a target.
  #    See the method llvm::TargetData::getIntPtrType.  
proc IntPtrType*(para1: TargetDataRef): TypeRef{.cdecl, dynlib: libname, 
    importc: "LLVMIntPtrType".}
  # Computes the size of a type in bytes for a target.
  #    See the method llvm::TargetData::getTypeSizeInBits.  
proc SizeOfTypeInBits*(para1: TargetDataRef, para2: TypeRef): int64{.cdecl, 
    dynlib: libname, importc: "LLVMSizeOfTypeInBits".}
  # Computes the storage size of a type in bytes for a target.
  #    See the method llvm::TargetData::getTypeStoreSize.  
proc StoreSizeOfType*(para1: TargetDataRef, para2: TypeRef): int64{.cdecl, 
    dynlib: libname, importc: "LLVMStoreSizeOfType".}
  # Computes the ABI size of a type in bytes for a target.
  #    See the method llvm::TargetData::getTypeAllocSize.  
proc ABISizeOfType*(para1: TargetDataRef, para2: TypeRef): int64{.cdecl, 
    dynlib: libname, importc: "LLVMABISizeOfType".}
  # Computes the ABI alignment of a type in bytes for a target.
  #    See the method llvm::TargetData::getTypeABISize.  
proc ABIAlignmentOfType*(para1: TargetDataRef, para2: TypeRef): int32{.cdecl, 
    dynlib: libname, importc: "LLVMABIAlignmentOfType".}
  # Computes the call frame alignment of a type in bytes for a target.
  #    See the method llvm::TargetData::getTypeABISize.  
proc CallFrameAlignmentOfType*(para1: TargetDataRef, para2: TypeRef): int32{.
    cdecl, dynlib: libname, importc: "LLVMCallFrameAlignmentOfType".}
  # Computes the preferred alignment of a type in bytes for a target.
  #    See the method llvm::TargetData::getTypeABISize.  
proc PreferredAlignmentOfType*(para1: TargetDataRef, para2: TypeRef): int32{.
    cdecl, dynlib: libname, importc: "LLVMPreferredAlignmentOfType".}
  # Computes the preferred alignment of a global variable in bytes for a target.
  #    See the method llvm::TargetData::getPreferredAlignment.  
proc PreferredAlignmentOfGlobal*(para1: TargetDataRef, GlobalVar: ValueRef): int32{.
    cdecl, dynlib: libname, importc: "LLVMPreferredAlignmentOfGlobal".}
  # Computes the structure element that contains the byte offset for a target.
  #    See the method llvm::StructLayout::getElementContainingOffset.  
proc ElementAtOffset*(para1: TargetDataRef, StructTy: TypeRef, Offset: int64): int32{.
    cdecl, dynlib: libname, importc: "LLVMElementAtOffset".}
  # Computes the byte offset of the indexed struct element for a target.
  #    See the method llvm::StructLayout::getElementContainingOffset.  
proc OffsetOfElement*(para1: TargetDataRef, StructTy: TypeRef, Element: int32): int64{.
    cdecl, dynlib: libname, importc: "LLVMOffsetOfElement".}
  # Struct layouts are speculatively cached. If a TargetDataRef is alive when
  #    types are being refined and removed, this method must be called whenever a
  #    struct type is removed to avoid a dangling pointer in this cache.
  #    See the method llvm::TargetData::InvalidateStructLayoutInfo.  
proc InvalidateStructLayout*(para1: TargetDataRef, StructTy: TypeRef){.cdecl, 
    dynlib: libname, importc: "LLVMInvalidateStructLayout".}
  # Deallocates a TargetData.
  #    See the destructor llvm::TargetData::~TargetData.  
proc DisposeTargetData*(para1: TargetDataRef){.cdecl, dynlib: libname, 
    importc: "LLVMDisposeTargetData".}
  # ExecutionEngine.h  
proc LinkInJIT*(){.cdecl, dynlib: libname, importc: "LLVMLinkInJIT".}
proc LinkInInterpreter*(){.cdecl, dynlib: libname, 
                           importc: "LLVMLinkInInterpreter".}
type 
  OpaqueGenericValue {.pure} = object
  OpaqueExecutionEngine {.pure} = object
  GenericValueRef* = OpaqueGenericValue
  ExecutionEngineRef* = OpaqueExecutionEngine
  
#===-- Operations on generic values --------------------------------------=== 

proc CreateGenericValueOfInt*(Ty: TypeRef, N: int64, IsSigned: int32): GenericValueRef{.
    cdecl, dynlib: libname, importc: "LLVMCreateGenericValueOfInt".}
proc CreateGenericValueOfPointer*(P: pointer): GenericValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMCreateGenericValueOfPointer".}
proc CreateGenericValueOfFloat*(Ty: TypeRef, N: float64): GenericValueRef{.
    cdecl, dynlib: libname, importc: "LLVMCreateGenericValueOfFloat".}
proc GenericValueIntWidth*(GenValRef: GenericValueRef): int32{.cdecl, 
    dynlib: libname, importc: "LLVMGenericValueIntWidth".}
proc GenericValueToInt*(GenVal: GenericValueRef, IsSigned: int32): int64{.cdecl, 
    dynlib: libname, importc: "LLVMGenericValueToInt".}
proc GenericValueToPointer*(GenVal: GenericValueRef): pointer{.cdecl, 
    dynlib: libname, importc: "LLVMGenericValueToPointer".}
proc GenericValueToFloat*(TyRef: TypeRef, GenVal: GenericValueRef): float64{.
    cdecl, dynlib: libname, importc: "LLVMGenericValueToFloat".}
proc DisposeGenericValue*(GenVal: GenericValueRef){.cdecl, dynlib: libname, 
    importc: "LLVMDisposeGenericValue".}
  
#===-- Operations on execution engines -----------------------------------=== 
proc CreateExecutionEngine*(OutEE: var ExecutionEngineRef, MP: ModuleProviderRef, 
                            OutError: var cstring): int32{.cdecl, dynlib: libname, 
    importc: "LLVMCreateExecutionEngine".}
proc CreateInterpreter*(OutInterp: var ExecutionEngineRef, MP: ModuleProviderRef, 
                        OutError: var cstring): int32{.cdecl, dynlib: libname, 
    importc: "LLVMCreateInterpreter".}
proc CreateJITCompiler*(OutJIT: var ExecutionEngineRef, MP: ModuleProviderRef, 
                        OptLevel: int32, OutError: var cstring): int32{.cdecl, 
    dynlib: libname, importc: "LLVMCreateJITCompiler".}
proc DisposeExecutionEngine*(EE: ExecutionEngineRef){.cdecl, dynlib: libname, 
    importc: "LLVMDisposeExecutionEngine".}
proc RunStaticConstructors*(EE: ExecutionEngineRef){.cdecl, dynlib: libname, 
    importc: "LLVMRunStaticConstructors".}
proc RunStaticDestructors*(EE: ExecutionEngineRef){.cdecl, dynlib: libname, 
    importc: "LLVMRunStaticDestructors".}

proc RunFunctionAsMain*(EE: ExecutionEngineRef, F: ValueRef, ArgC: int32, 
                        ArgV: cstringArray, EnvP: cstringArray): int32{.cdecl, 
    dynlib: libname, importc: "LLVMRunFunctionAsMain".}
proc RunFunction*(EE: ExecutionEngineRef, F: ValueRef, NumArgs: int32, 
                  Args: ptr GenericValueRef): GenericValueRef{.cdecl, 
    dynlib: libname, importc: "LLVMRunFunction".}
proc FreeMachineCodeForFunction*(EE: ExecutionEngineRef, F: ValueRef){.cdecl, 
    dynlib: libname, importc: "LLVMFreeMachineCodeForFunction".}
proc AddModuleProvider*(EE: ExecutionEngineRef, MP: ModuleProviderRef){.cdecl, 
    dynlib: libname, importc: "LLVMAddModuleProvider".}
proc RemoveModuleProvider*(EE: ExecutionEngineRef, MP: ModuleProviderRef, 
                           OutMod: var ModuleRef, OutError: var cstring): int32{.cdecl, 
    dynlib: libname, importc: "LLVMRemoveModuleProvider".}
proc FindFunction*(EE: ExecutionEngineRef, Name: cstring, OutFn: var ValueRef): int32{.
    cdecl, dynlib: libname, importc: "LLVMFindFunction".}
proc GetExecutionEngineTargetData*(EE: ExecutionEngineRef): TargetDataRef{.
    cdecl, dynlib: libname, importc: "LLVMGetExecutionEngineTargetData".}
proc AddGlobalMapping*(EE: ExecutionEngineRef, Global: ValueRef, 
                       theAddr: pointer){.cdecl, dynlib: libname, 
    importc: "LLVMAddGlobalMapping".}
proc GetPointerToGlobal*(EE: ExecutionEngineRef, Global: ValueRef): pointer{.
    cdecl, dynlib: libname, importc: "LLVMGetPointerToGlobal".}

# LinkTimeOptimizer.h  
# This provides a dummy type for pointers to the LTO object. 
type 
  lto_t* = pointer
  lto_status* = enum 
    LTO_UNKNOWN, LTO_OPT_SUCCESS, LTO_READ_SUCCESS, LTO_READ_FAILURE, 
    LTO_WRITE_FAILURE, LTO_NO_TARGET, LTO_NO_WORK, LTO_MODULE_MERGE_FAILURE, 
    LTO_ASM_FAILURE, LTO_NULL_OBJECT
  lto_status_t* = lto_status
  # This provides C interface to initialize link time optimizer. This allows 
  # linker to use dlopen() interface to dynamically load LinkTimeOptimizer. 
  # extern "C" helps, because dlopen() interface uses name to find the symbol. 

proc create_optimizer*(): lto_t{.cdecl, dynlib: libname, 
                                 importc: "llvm_create_optimizer".}
proc destroy_optimizer*(lto: lto_t){.cdecl, dynlib: libname, 
                                     importc: "llvm_destroy_optimizer".}
proc read_object_file*(lto: lto_t, input_filename: cstring): lto_status_t{.
    cdecl, dynlib: libname, importc: "llvm_read_object_file".}
proc optimize_modules*(lto: lto_t, output_filename: cstring): lto_status_t{.
    cdecl, dynlib: libname, importc: "llvm_optimize_modules".}
  
# lto.h  
const 
  LTO_API_VERSION* = 3        # log2 of alignment  

type 
  lto_symbol_attributes* = enum 
    SYMBOL_ALIGNMENT_MASK = 0x0000001F,
    SYMBOL_PERMISSIONS_RODATA = 0x00000080,
    SYMBOL_PERMISSIONS_CODE = 0x000000A0,
    SYMBOL_PERMISSIONS_DATA = 0x000000C0, 
    SYMBOL_PERMISSIONS_MASK = 0x000000E0, 
    
    SYMBOL_DEFINITION_REGULAR = 0x00000100, 
    SYMBOL_DEFINITION_TENTATIVE = 0x00000200, 
    SYMBOL_DEFINITION_WEAK = 0x00000300, 
    SYMBOL_DEFINITION_UNDEFINED = 0x00000400, 
    SYMBOL_DEFINITION_WEAKUNDEF = 0x00000500,
    SYMBOL_DEFINITION_MASK = 0x00000700, 
    SYMBOL_SCOPE_INTERNAL = 0x00000800,
    
    SYMBOL_SCOPE_HIDDEN = 0x00001000,
    SYMBOL_SCOPE_DEFAULT = 0x00001800,
    SYMBOL_SCOPE_PROTECTED = 0x00002000,
    SYMBOL_SCOPE_MASK = 0x00003800, 
  lto_debug_model* = enum 
    DEBUG_MODEL_NONE = 0, DEBUG_MODEL_DWARF = 1
  lto_codegen_model* = enum
    CODEGEN_PIC_MODEL_STATIC = 0, CODEGEN_PIC_MODEL_DYNAMIC = 1, 
    CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC = 2
  
  LTOModule {.pure} = object
  LTOCodeGenerator {.pure} = object
  lto_module_t* = ref LTOModule
  lto_code_gen_t* = ref LTOCodeGenerator

proc lto_get_version*(): cstring{.cdecl, dynlib: libname, 
                                  importc: "lto_get_version".}
  #
  # Returns the last error string or NULL if last operation was sucessful.
  #  
proc lto_get_error_message*(): cstring{.cdecl, dynlib: libname, 
                                        importc: "lto_get_error_message".}
  #
  # Checks if a file is a loadable object file.
  #  
proc lto_module_is_object_file*(path: cstring): bool{.cdecl, dynlib: libname, 
    importc: "lto_module_is_object_file".}
  #
  # Checks if a file is a loadable object compiled for requested target.
  #  
proc lto_module_is_object_file_for_target*(path: cstring, 
    target_triple_prefix: cstring): bool{.cdecl, dynlib: libname, 
    importc: "lto_module_is_object_file_for_target".}
  #
  # Checks if a buffer is a loadable object file.
  #  
proc lto_module_is_object_file_in_memory*(mem: pointer, len: int): bool{.
    cdecl, dynlib: libname, importc: "lto_module_is_object_file_in_memory".}
  #
  # Checks if a buffer is a loadable object compiled for requested target.
  #  
proc lto_module_is_object_file_in_memory_for_target*(mem: pointer, len: int, 
    target_triple_prefix: cstring): bool{.cdecl, dynlib: libname, 
    importc: "lto_module_is_object_file_in_memory_for_target".}
  #
  # Loads an object file from disk.
  # Returns NULL on error (check lto_get_error_message() for details).
  #  
proc lto_module_create*(path: cstring): lto_module_t{.cdecl, dynlib: libname, 
    importc: "lto_module_create".}
  #
  # Loads an object file from memory.
  # Returns NULL on error (check lto_get_error_message() for details).
  #  
proc lto_module_create_from_memory*(mem: pointer, len: int): lto_module_t{.
    cdecl, dynlib: libname, importc: "lto_module_create_from_memory".}
  #
  # Frees all memory internally allocated by the module.
  # Upon return the lto_module_t is no longer valid.
  #  
proc lto_module_dispose*(module: lto_module_t){.cdecl, dynlib: libname, 
    importc: "lto_module_dispose".}
  #
  # Returns triple string which the object module was compiled under.
  #  
proc lto_module_get_target_triple*(module: lto_module_t): cstring{.cdecl, 
    dynlib: libname, importc: "lto_module_get_target_triple".}
  #
  # Returns the number of symbols in the object module.
  #  
proc lto_module_get_num_symbols*(module: lto_module_t): int32{.cdecl, 
    dynlib: libname, importc: "lto_module_get_num_symbols".}
  #
  # Returns the name of the ith symbol in the object module.
  #  
proc lto_module_get_symbol_name*(module: lto_module_t, index: int32): cstring{.
    cdecl, dynlib: libname, importc: "lto_module_get_symbol_name".}
  #
  # Returns the attributes of the ith symbol in the object module.
  #  
proc lto_module_get_symbol_attribute*(module: lto_module_t, index: int32): lto_symbol_attributes{.
    cdecl, dynlib: libname, importc: "lto_module_get_symbol_attribute".}
  #
  # Instantiates a code generator.
  # Returns NULL on error (check lto_get_error_message() for details).
  #  
proc lto_codegen_create*(): lto_code_gen_t{.cdecl, dynlib: libname, 
    importc: "lto_codegen_create".}
  #
  # Frees all code generator and all memory it internally allocated.
  # Upon return the lto_code_gen_t is no longer valid.
  #  
proc lto_codegen_dispose*(para1: lto_code_gen_t){.cdecl, dynlib: libname, 
    importc: "lto_codegen_dispose".}
  #
  # Add an object module to the set of modules for which code will be generated.
  # Returns true on error (check lto_get_error_message() for details).
  #  
proc lto_codegen_add_module*(cg: lto_code_gen_t, module: lto_module_t): bool{.
    cdecl, dynlib: libname, importc: "lto_codegen_add_module".}
  #
  # Sets if debug info should be generated.
  # Returns true on error (check lto_get_error_message() for details).
  #  
proc lto_codegen_set_debug_model*(cg: lto_code_gen_t, para2: lto_debug_model): bool{.
    cdecl, dynlib: libname, importc: "lto_codegen_set_debug_model".}
  #
  # Sets which PIC code model to generated.
  # Returns true on error (check lto_get_error_message() for details).
  #  
proc lto_codegen_set_pic_model*(cg: lto_code_gen_t, para2: lto_codegen_model): bool{.
    cdecl, dynlib: libname, importc: "lto_codegen_set_pic_model".}
  #
  # Sets the location of the "gcc" to run. If not set, libLTO will search for
  # "gcc" on the path.
  #  
proc lto_codegen_set_gcc_path*(cg: lto_code_gen_t, path: cstring){.cdecl, 
    dynlib: libname, importc: "lto_codegen_set_gcc_path".}
  #
  # Sets the location of the assembler tool to run. If not set, libLTO
  # will use gcc to invoke the assembler.
  #  
proc lto_codegen_set_assembler_path*(cg: lto_code_gen_t, path: cstring){.cdecl, 
    dynlib: libname, importc: "lto_codegen_set_assembler_path".}
  #
  # Adds to a list of all global symbols that must exist in the final
  # generated code.  If a function is not listed, it might be
  # inlined into every usage and optimized away.
  #  
proc lto_codegen_add_must_preserve_symbol*(cg: lto_code_gen_t, symbol: cstring){.
    cdecl, dynlib: libname, importc: "lto_codegen_add_must_preserve_symbol".}
  #
  # Writes a new object file at the specified path that contains the
  # merged contents of all modules added so far.
  # Returns true on error (check lto_get_error_message() for details).
  #  
proc lto_codegen_write_merged_modules*(cg: lto_code_gen_t, path: cstring): bool{.
    cdecl, dynlib: libname, importc: "lto_codegen_write_merged_modules".}
  #
  # Generates code for all added modules into one native object file.
  # On sucess returns a pointer to a generated mach-o/ELF buffer and
  # length set to the buffer size.  The buffer is owned by the 
  # lto_code_gen_t and will be freed when lto_codegen_dispose()
  # is called, or lto_codegen_compile() is called again.
  # On failure, returns NULL (check lto_get_error_message() for details).
  #  
proc lto_codegen_compile*(cg: lto_code_gen_t, len: var int): pointer{.cdecl, 
    dynlib: libname, importc: "lto_codegen_compile".}
  #
  # Sets options to help debug codegen bugs.
  #  
proc lto_codegen_debug_options*(cg: lto_code_gen_t, para2: cstring){.cdecl, 
    dynlib: libname, importc: "lto_codegen_debug_options".}