1 files changed, 658 insertions, 0 deletions
diff --git a/rod/llvmdyn.nim b/rod/llvmdyn.nim
new file mode 100755
index 000000000..09bc48ce2
--- /dev/null
+++ b/rod/llvmdyn.nim
@@ -0,0 +1,658 @@
+#
+#
+#           The Nimrod Compiler
+#        (c) Copyright 2009 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+# this module implements the interface to LLVM.
+
+const 
+  llvmdll* = "llvm.dll" # Opaque types.  
+                        #
+                        #  The top-level container for all other LLVM Intermediate Representation (IR)
+                        #  objects. See the llvm::Module class.
+                        #
+
+type 
+  cuint* = int32
+  PLLVMBasicBlockRef* = ref TLLVMBasicBlockRef
+  PLLVMMemoryBufferRef* = ref TLLVMMemoryBufferRef
+  PLLVMTypeRef* = ref TLLVMTypeRef
+  PLLVMValueRef* = ref TLLVMValueRef
+  TLLVMOpaqueModule*{.final.} = object 
+  TLLVMModuleRef* = ref TLLVMOpaqueModule #
+                                          #  Each value in the LLVM IR has a type, an instance of [lltype]. See the
+                                          #  llvm: : Type class.
+                                          #
+  TLLVMOpaqueType*{.final.} = object 
+  TLLVMTypeRef* = ref TLLVMOpaqueType #
+                                      #  When building recursive types using [refine_type], [lltype] values may become
+                                      #  invalid; use [lltypehandle] to resolve this problem. See the
+                                      #  llvm: : AbstractTypeHolder] class.
+                                      #
+  TLLVMOpaqueTypeHandle*{.final.} = object 
+  TLLVMTypeHandleRef* = ref TLLVMOpaqueTypeHandle
+  TLLVMOpaqueValue*{.final.} = object 
+  TLLVMValueRef* = ref TLLVMOpaqueValue
+  TLLVMOpaqueBasicBlock*{.final.} = object 
+  TLLVMBasicBlockRef* = ref TLLVMOpaqueBasicBlock
+  TLLVMOpaqueBuilder*{.final.} = object 
+  TLLVMBuilderRef* = ref TLLVMOpaqueBuilder # Used to provide a module to JIT or interpreter.
+                                            #  See the llvm: : ModuleProvider class.
+                                            #
+  TLLVMOpaqueModuleProvider*{.final.} = object 
+  TLLVMModuleProviderRef* = ref TLLVMOpaqueModuleProvider # Used to provide a module to JIT or interpreter.
+                                                          #  See the llvm: : MemoryBuffer class.
+                                                          #
+  TLLVMOpaqueMemoryBuffer*{.final.} = object 
+  TLLVMMemoryBufferRef* = ref TLLVMOpaqueMemoryBuffer
+  TLLVMTypeKind* = enum 
+    LLVMVoidTypeKind,         # type with no size
+    LLVMFloatTypeKind,        # 32 bit floating point type
+    LLVMDoubleTypeKind,       # 64 bit floating point type
+    LLVMX86_FP80TypeKind,     # 80 bit floating point type (X87)
+    LLVMFP128TypeKind,        # 128 bit floating point type (112-bit mantissa)
+    LLVMPPC_FP128TypeKind,    # 128 bit floating point type (two 64-bits)
+    LLVMLabelTypeKind,        # Labels
+    LLVMIntegerTypeKind,      # Arbitrary bit width integers
+    LLVMFunctionTypeKind,     # Functions
+    LLVMStructTypeKind,       # Structures
+    LLVMArrayTypeKind,        # Arrays
+    LLVMPointerTypeKind,      # Pointers
+    LLVMOpaqueTypeKind,       # Opaque: type with unknown structure
+    LLVMVectorTypeKind        # SIMD 'packed' format, or other vector type
+  TLLVMLinkage* = enum 
+    LLVMExternalLinkage,      # Externally visible function
+    LLVMLinkOnceLinkage,      # Keep one copy of function when linking (inline)
+    LLVMWeakLinkage,          # Keep one copy of function when linking (weak)
+    LLVMAppendingLinkage,     # Special purpose, only applies to global arrays
+    LLVMInternalLinkage,      # Rename collisions when linking (static functions)
+    LLVMDLLImportLinkage,     # Function to be imported from DLL
+    LLVMDLLExportLinkage,     # Function to be accessible from DLL
+    LLVMExternalWeakLinkage,  # ExternalWeak linkage description
+    LLVMGhostLinkage          # Stand-in functions for streaming fns from bitcode
+  TLLVMVisibility* = enum 
+    LLVMDefaultVisibility,    # The GV is visible
+    LLVMHiddenVisibility,     # The GV is hidden
+    LLVMProtectedVisibility   # The GV is protected
+  TLLVMCallConv* = enum 
+    LLVMCCallConv = 0, LLVMFastCallConv = 8, LLVMColdCallConv = 9, 
+    LLVMX86StdcallCallConv = 64, LLVMX86FastcallCallConv = 65
+  TLLVMIntPredicate* = enum 
+    LLVMIntEQ = 32,           # equal
+    LLVMIntNE,                # not equal
+    LLVMIntUGT,               # unsigned greater than
+    LLVMIntUGE,               # unsigned greater or equal
+    LLVMIntULT,               # unsigned less than
+    LLVMIntULE,               # unsigned less or equal
+    LLVMIntSGT,               # signed greater than
+    LLVMIntSGE,               # signed greater or equal
+    LLVMIntSLT,               # signed less than
+    LLVMIntSLE                # signed less or equal
+  TLLVMRealPredicate* = enum  #===-- Error handling ----------------------------------------------------=== 
+    LLVMRealPredicateFalse,   # Always false (always folded)
+    LLVMRealOEQ,              # True if ordered and equal
+    LLVMRealOGT,              # True if ordered and greater than
+    LLVMRealOGE,              # True if ordered and greater than or equal
+    LLVMRealOLT,              # True if ordered and less than
+    LLVMRealOLE,              # True if ordered and less than or equal
+    LLVMRealONE,              # True if ordered and operands are unequal
+    LLVMRealORD,              # True if ordered (no nans)
+    LLVMRealUNO,              # True if unordered: isnan(X) | isnan(Y)
+    LLVMRealUEQ,              # True if unordered or equal
+    LLVMRealUGT,              # True if unordered or greater than
+    LLVMRealUGE,              # True if unordered, greater than, or equal
+    LLVMRealULT,              # True if unordered or less than
+    LLVMRealULE,              # True if unordered, less than, or equal
+    LLVMRealUNE,              # True if unordered or not equal
+    LLVMRealPredicateTrue     # Always true (always folded)
+
+proc LLVMDisposeMessage*(msg: cstring){.cdecl, dynlib: llvmdll, importc.}
+  #===-- Modules -----------------------------------------------------------=== 
+  # Create and destroy modules.  
+proc LLVMModuleCreateWithName*(ModuleID: cstring): TLLVMModuleRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMDisposeModule*(M: TLLVMModuleRef){.cdecl, dynlib: llvmdll, importc.}
+  # Data layout  
+proc LLVMGetDataLayout*(M: TLLVMModuleRef): cstring{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMSetDataLayout*(M: TLLVMModuleRef, Triple: cstring){.cdecl, 
+    dynlib: llvmdll, importc.}
+  # Target triple  
+proc LLVMGetTarget*(M: TLLVMModuleRef): cstring{.cdecl, dynlib: llvmdll, importc.}
+  # Const before type ignored 
+proc LLVMSetTarget*(M: TLLVMModuleRef, Triple: cstring){.cdecl, dynlib: llvmdll, 
+    importc.}
+  # Same as Module: : addTypeName.  
+proc LLVMAddTypeName*(M: TLLVMModuleRef, Name: cstring, Ty: TLLVMTypeRef): int32{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMDeleteTypeName*(M: TLLVMModuleRef, Name: cstring){.cdecl, 
+    dynlib: llvmdll, importc.}
+  #===-- 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
+  #  
+proc LLVMGetTypeKind*(Ty: TLLVMTypeRef): TLLVMTypeKind{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMRefineAbstractType*(AbstractType: TLLVMTypeRef, 
+                             ConcreteType: TLLVMTypeRef){.cdecl, 
+    dynlib: llvmdll, importc.}
+  # Operations on integer types  
+proc LLVMInt1Type*(): TLLVMTypeRef{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMInt8Type*(): TLLVMTypeRef{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMInt16Type*(): TLLVMTypeRef{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMInt32Type*(): TLLVMTypeRef{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMInt64Type*(): TLLVMTypeRef{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMIntType*(NumBits: cuint): TLLVMTypeRef{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMGetIntTypeWidth*(IntegerTy: TLLVMTypeRef): cuint{.cdecl, 
+    dynlib: llvmdll, importc.}
+  # Operations on real types  
+proc LLVMFloatType*(): TLLVMTypeRef{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMDoubleType*(): TLLVMTypeRef{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMX86FP80Type*(): TLLVMTypeRef{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMFP128Type*(): TLLVMTypeRef{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMPPCFP128Type*(): TLLVMTypeRef{.cdecl, dynlib: llvmdll, importc.}
+  # Operations on function types  
+proc LLVMFunctionType*(ReturnType: TLLVMTypeRef, ParamTypes: PLLVMTypeRef, 
+                       ParamCount: cuint, IsVarArg: int32): TLLVMTypeRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMIsFunctionVarArg*(FunctionTy: TLLVMTypeRef): int32{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMGetReturnType*(FunctionTy: TLLVMTypeRef): TLLVMTypeRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMCountParamTypes*(FunctionTy: TLLVMTypeRef): cuint{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMGetParamTypes*(FunctionTy: TLLVMTypeRef, Dest: PLLVMTypeRef){.cdecl, 
+    dynlib: llvmdll, importc.}
+  # Operations on struct types  
+proc LLVMStructType*(ElementTypes: PLLVMTypeRef, ElementCount: cuint, 
+                     isPacked: int32): TLLVMTypeRef{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMCountStructElementTypes*(StructTy: TLLVMTypeRef): cuint{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMGetStructElementTypes*(StructTy: TLLVMTypeRef, Dest: pLLVMTypeRef){.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMIsPackedStruct*(StructTy: TLLVMTypeRef): int32{.cdecl, dynlib: llvmdll, 
+    importc.}
+  # Operations on array, pointer, and vector types (sequence types)  
+proc LLVMArrayType*(ElementType: TLLVMTypeRef, ElementCount: cuint): TLLVMTypeRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMPointerType*(ElementType: TLLVMTypeRef, AddressSpace: cuint): TLLVMTypeRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMVectorType*(ElementType: TLLVMTypeRef, ElementCount: cuint): TLLVMTypeRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMGetElementType*(Ty: TLLVMTypeRef): TLLVMTypeRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMGetArrayLength*(ArrayTy: TLLVMTypeRef): cuint{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMGetPointerAddressSpace*(PointerTy: TLLVMTypeRef): cuint{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMGetVectorSize*(VectorTy: TLLVMTypeRef): cuint{.cdecl, dynlib: llvmdll, 
+    importc.}
+  # Operations on other types  
+proc LLVMVoidType*(): TLLVMTypeRef{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMLabelType*(): TLLVMTypeRef{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMOpaqueType*(): TLLVMTypeRef{.cdecl, dynlib: llvmdll, importc.}
+  # Operations on type handles  
+proc LLVMCreateTypeHandle*(PotentiallyAbstractTy: TLLVMTypeRef): TLLVMTypeHandleRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMRefineType*(AbstractTy: TLLVMTypeRef, ConcreteTy: TLLVMTypeRef){.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMResolveTypeHandle*(TypeHandle: TLLVMTypeHandleRef): TLLVMTypeRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMDisposeTypeHandle*(TypeHandle: TLLVMTypeHandleRef){.cdecl, 
+    dynlib: llvmdll, importc.}
+  #===-- Values ------------------------------------------------------------=== 
+  # The bulk of LLVM's object model consists of values, which comprise a very
+  # * rich type hierarchy.
+  # *
+  # *   values:
+  # *     constants:
+  # *       scalar constants
+  # *       composite contants
+  # *       globals:
+  # *         global variable
+  # *         function
+  # *         alias
+  # *       basic blocks
+  #  
+  # Operations on all values  
+proc LLVMTypeOf*(Val: TLLVMValueRef): TLLVMTypeRef{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMGetValueName*(Val: TLLVMValueRef): cstring{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMSetValueName*(Val: TLLVMValueRef, Name: cstring){.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMDumpValue*(Val: TLLVMValueRef){.cdecl, dynlib: llvmdll, importc.}
+  # Operations on constants of any type  
+proc LLVMConstNull*(Ty: TLLVMTypeRef): TLLVMValueRef{.cdecl, dynlib: llvmdll, 
+    importc.}
+  # all zeroes  
+proc LLVMConstAllOnes*(Ty: TLLVMTypeRef): TLLVMValueRef{.cdecl, dynlib: llvmdll, 
+    importc.}
+  # only for int/vector  
+proc LLVMGetUndef*(Ty: TLLVMTypeRef): TLLVMValueRef{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMIsConstant*(Val: TLLVMValueRef): int32{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMIsNull*(Val: TLLVMValueRef): int32{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMIsUndef*(Val: TLLVMValueRef): int32{.cdecl, dynlib: llvmdll, importc.}
+  # Operations on scalar constants  
+proc LLVMConstInt*(IntTy: TLLVMTypeRef, N: qword, SignExtend: int32): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstReal*(RealTy: TLLVMTypeRef, N: float64): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+  # Operations on composite constants  
+proc LLVMConstString*(Str: cstring, len: cuint, DontNullTerminate: int32): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstArray*(ArrayTy: TLLVMTypeRef, ConstantVals: pLLVMValueRef, 
+                     len: cuint): TLLVMValueRef{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstStruct*(ConstantVals: pLLVMValueRef, Count: cuint, ispacked: int32): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstVector*(ScalarConstantVals: pLLVMValueRef, Size: cuint): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+  # Constant expressions  
+proc LLVMSizeOf*(Ty: TLLVMTypeRef): TLLVMValueRef{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMConstNeg*(ConstantVal: TLLVMValueRef): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMConstNot*(ConstantVal: TLLVMValueRef): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMConstAdd*(LHSConstant: TLLVMValueRef, RHSConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstSub*(LHSConstant: TLLVMValueRef, RHSConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstMul*(LHSConstant: TLLVMValueRef, RHSConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstUDiv*(LHSConstant: TLLVMValueRef, RHSConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstSDiv*(LHSConstant: TLLVMValueRef, RHSConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstFDiv*(LHSConstant: TLLVMValueRef, RHSConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstURem*(LHSConstant: TLLVMValueRef, RHSConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstSRem*(LHSConstant: TLLVMValueRef, RHSConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstFRem*(LHSConstant: TLLVMValueRef, RHSConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstAnd*(LHSConstant: TLLVMValueRef, RHSConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstOr*(LHSConstant: TLLVMValueRef, RHSConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstXor*(LHSConstant: TLLVMValueRef, RHSConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstICmp*(Predicate: TLLVMIntPredicate, LHSConstant: TLLVMValueRef, 
+                    RHSConstant: TLLVMValueRef): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMConstFCmp*(Predicate: TLLVMRealPredicate, LHSConstant: TLLVMValueRef, 
+                    RHSConstant: TLLVMValueRef): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMConstShl*(LHSConstant: TLLVMValueRef, RHSConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstLShr*(LHSConstant: TLLVMValueRef, RHSConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstAShr*(LHSConstant: TLLVMValueRef, RHSConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstGEP*(ConstantVal: TLLVMValueRef, ConstantIndices: PLLVMValueRef, 
+                   NumIndices: cuint): TLLVMValueRef{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMConstTrunc*(ConstantVal: TLLVMValueRef, ToType: TLLVMTypeRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstSExt*(ConstantVal: TLLVMValueRef, ToType: TLLVMTypeRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstZExt*(ConstantVal: TLLVMValueRef, ToType: TLLVMTypeRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstFPTrunc*(ConstantVal: TLLVMValueRef, ToType: TLLVMTypeRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstFPExt*(ConstantVal: TLLVMValueRef, ToType: TLLVMTypeRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstUIToFP*(ConstantVal: TLLVMValueRef, ToType: TLLVMTypeRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstSIToFP*(ConstantVal: TLLVMValueRef, ToType: TLLVMTypeRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstFPToUI*(ConstantVal: TLLVMValueRef, ToType: TLLVMTypeRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstFPToSI*(ConstantVal: TLLVMValueRef, ToType: TLLVMTypeRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstPtrToInt*(ConstantVal: TLLVMValueRef, ToType: TLLVMTypeRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstIntToPtr*(ConstantVal: TLLVMValueRef, ToType: TLLVMTypeRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstBitCast*(ConstantVal: TLLVMValueRef, ToType: TLLVMTypeRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstSelect*(ConstantCondition: TLLVMValueRef, 
+                      ConstantIfTrue: TLLVMValueRef, 
+                      ConstantIfFalse: TLLVMValueRef): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMConstExtractElement*(VectorConstant: TLLVMValueRef, 
+                              IndexConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstInsertElement*(VectorConstant: TLLVMValueRef, 
+                             ElementValueConstant: TLLVMValueRef, 
+                             IndexConstant: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMConstShuffleVector*(VectorAConstant: TLLVMValueRef, 
+                             VectorBConstant: TLLVMValueRef, 
+                             MaskConstant: TLLVMValueRef): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+  # Operations on global variables, functions, and aliases (globals)  
+proc LLVMIsDeclaration*(Global: TLLVMValueRef): int32{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMGetLinkage*(Global: TLLVMValueRef): TLLVMLinkage{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMSetLinkage*(Global: TLLVMValueRef, Linkage: TLLVMLinkage){.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMGetSection*(Global: TLLVMValueRef): cstring{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMSetSection*(Global: TLLVMValueRef, Section: cstring){.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMGetVisibility*(Global: TLLVMValueRef): TLLVMVisibility{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMSetVisibility*(Global: TLLVMValueRef, Viz: TLLVMVisibility){.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMGetAlignment*(Global: TLLVMValueRef): cuint{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMSetAlignment*(Global: TLLVMValueRef, Bytes: cuint){.cdecl, 
+    dynlib: llvmdll, importc.}
+  # Operations on global variables  
+  # Const before type ignored 
+proc LLVMAddGlobal*(M: TLLVMModuleRef, Ty: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+  # Const before type ignored 
+proc LLVMGetNamedGlobal*(M: TLLVMModuleRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMDeleteGlobal*(GlobalVar: TLLVMValueRef){.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMHasInitializer*(GlobalVar: TLLVMValueRef): int32{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMGetInitializer*(GlobalVar: TLLVMValueRef): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMSetInitializer*(GlobalVar: TLLVMValueRef, ConstantVal: TLLVMValueRef){.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMIsThreadLocal*(GlobalVar: TLLVMValueRef): int32{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMSetThreadLocal*(GlobalVar: TLLVMValueRef, IsThreadLocal: int32){.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMIsGlobalConstant*(GlobalVar: TLLVMValueRef): int32{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMSetGlobalConstant*(GlobalVar: TLLVMValueRef, IsConstant: int32){.cdecl, 
+    dynlib: llvmdll, importc.}
+  # Operations on functions  
+  # Const before type ignored 
+proc LLVMAddFunction*(M: TLLVMModuleRef, Name: cstring, FunctionTy: TLLVMTypeRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+  # Const before type ignored 
+proc LLVMGetNamedFunction*(M: TLLVMModuleRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMDeleteFunction*(Fn: TLLVMValueRef){.cdecl, dynlib: llvmdll, importc.}
+proc LLVMCountParams*(Fn: TLLVMValueRef): cuint{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMGetParams*(Fn: TLLVMValueRef, Params: PLLVMValueRef){.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMGetParam*(Fn: TLLVMValueRef, Index: cuint): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMGetIntrinsicID*(Fn: TLLVMValueRef): cuint{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMGetFunctionCallConv*(Fn: TLLVMValueRef): cuint{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMSetFunctionCallConv*(Fn: TLLVMValueRef, CC: cuint){.cdecl, 
+    dynlib: llvmdll, importc.}
+  # Const before type ignored 
+proc LLVMGetCollector*(Fn: TLLVMValueRef): cstring{.cdecl, dynlib: llvmdll, 
+    importc.}
+  # Const before type ignored 
+proc LLVMSetCollector*(Fn: TLLVMValueRef, Coll: cstring){.cdecl, 
+    dynlib: llvmdll, importc.}
+  # Operations on basic blocks  
+proc LLVMBasicBlockAsValue*(Bb: TLLVMBasicBlockRef): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMValueIsBasicBlock*(Val: TLLVMValueRef): int32{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMValueAsBasicBlock*(Val: TLLVMValueRef): TLLVMBasicBlockRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMCountBasicBlocks*(Fn: TLLVMValueRef): cuint{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMGetBasicBlocks*(Fn: TLLVMValueRef, BasicBlocks: PLLVMBasicBlockRef){.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMGetEntryBasicBlock*(Fn: TLLVMValueRef): TLLVMBasicBlockRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+  # Const before type ignored 
+proc LLVMAppendBasicBlock*(Fn: TLLVMValueRef, Name: cstring): TLLVMBasicBlockRef{.
+    cdecl, dynlib: llvmdll, importc.}
+  # Const before type ignored 
+proc LLVMInsertBasicBlock*(InsertBeforeBB: TLLVMBasicBlockRef, Name: cstring): TLLVMBasicBlockRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMDeleteBasicBlock*(BB: TLLVMBasicBlockRef){.cdecl, dynlib: llvmdll, 
+    importc.}
+  # Operations on call sites  
+proc LLVMSetInstructionCallConv*(Instr: TLLVMValueRef, CC: cuint){.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMGetInstructionCallConv*(Instr: TLLVMValueRef): cuint{.cdecl, 
+    dynlib: llvmdll, importc.}
+  # Operations on phi nodes  
+proc LLVMAddIncoming*(PhiNode: TLLVMValueRef, IncomingValues: PLLVMValueRef, 
+                      IncomingBlocks: PLLVMBasicBlockRef, Count: cuint){.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMCountIncoming*(PhiNode: TLLVMValueRef): cuint{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMGetIncomingValue*(PhiNode: TLLVMValueRef, Index: cuint): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMGetIncomingBlock*(PhiNode: TLLVMValueRef, Index: cuint): TLLVMBasicBlockRef{.
+    cdecl, dynlib: llvmdll, importc.}
+  #===-- 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 LLVMCreateBuilder*(): TLLVMBuilderRef{.cdecl, dynlib: llvmdll, importc.}
+proc LLVMPositionBuilderBefore*(Builder: TLLVMBuilderRef, Instr: TLLVMValueRef){.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMPositionBuilderAtEnd*(Builder: TLLVMBuilderRef, 
+                               theBlock: TLLVMBasicBlockRef){.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMDisposeBuilder*(Builder: TLLVMBuilderRef){.cdecl, dynlib: llvmdll, 
+    importc.}
+  # Terminators  
+proc LLVMBuildRetVoid*(para1: TLLVMBuilderRef): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildRet*(para1: TLLVMBuilderRef, V: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildBr*(para1: TLLVMBuilderRef, Dest: TLLVMBasicBlockRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildCondBr*(para1: TLLVMBuilderRef, IfCond: TLLVMValueRef, 
+                      ThenBranch: TLLVMBasicBlockRef, 
+                      ElseBranch: TLLVMBasicBlockRef): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildSwitch*(para1: TLLVMBuilderRef, V: TLLVMValueRef, 
+                      ElseBranch: TLLVMBasicBlockRef, NumCases: cuint): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+  # Const before type ignored 
+proc LLVMBuildInvoke*(para1: TLLVMBuilderRef, Fn: TLLVMValueRef, 
+                      Args: PLLVMValueRef, NumArgs: cuint, 
+                      ThenBranch: TLLVMBasicBlockRef, Catch: TLLVMBasicBlockRef, 
+                      Name: cstring): TLLVMValueRef{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMBuildUnwind*(para1: TLLVMBuilderRef): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildUnreachable*(para1: TLLVMBuilderRef): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+  # Add a case to the switch instruction  
+proc LLVMAddCase*(Switch: TLLVMValueRef, OnVal: TLLVMValueRef, 
+                  Dest: TLLVMBasicBlockRef){.cdecl, dynlib: llvmdll, importc.}
+  # Arithmetic  
+proc LLVMBuildAdd*(para1: TLLVMBuilderRef, LHS: TLLVMValueRef, 
+                   RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildSub*(para1: TLLVMBuilderRef, LHS: TLLVMValueRef, 
+                   RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildMul*(para1: TLLVMBuilderRef, LHS: TLLVMValueRef, 
+                   RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildUDiv*(para1: TLLVMBuilderRef, LHS: TLLVMValueRef, 
+                    RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildSDiv*(para1: TLLVMBuilderRef, LHS: TLLVMValueRef, 
+                    RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildFDiv*(para1: TLLVMBuilderRef, LHS: TLLVMValueRef, 
+                    RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildURem*(para1: TLLVMBuilderRef, LHS: TLLVMValueRef, 
+                    RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildSRem*(para1: TLLVMBuilderRef, LHS: TLLVMValueRef, 
+                    RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildFRem*(para1: TLLVMBuilderRef, LHS: TLLVMValueRef, 
+                    RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildShl*(para1: TLLVMBuilderRef, LHS: TLLVMValueRef, 
+                   RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildLShr*(para1: TLLVMBuilderRef, LHS: TLLVMValueRef, 
+                    RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildAShr*(para1: TLLVMBuilderRef, LHS: TLLVMValueRef, 
+                    RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildAnd*(para1: TLLVMBuilderRef, LHS: TLLVMValueRef, 
+                   RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildOr*(para1: TLLVMBuilderRef, LHS: TLLVMValueRef, 
+                  RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildXor*(para1: TLLVMBuilderRef, LHS: TLLVMValueRef, 
+                   RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildNeg*(para1: TLLVMBuilderRef, V: TLLVMValueRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildNot*(para1: TLLVMBuilderRef, V: TLLVMValueRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+  # Memory  
+proc LLVMBuildMalloc*(para1: TLLVMBuilderRef, Ty: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildArrayMalloc*(para1: TLLVMBuilderRef, Ty: TLLVMTypeRef, 
+                           Val: TLLVMValueRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildAlloca*(para1: TLLVMBuilderRef, Ty: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildArrayAlloca*(para1: TLLVMBuilderRef, Ty: TLLVMTypeRef, 
+                           Val: TLLVMValueRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildFree*(para1: TLLVMBuilderRef, PointerVal: TLLVMValueRef): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildLoad*(para1: TLLVMBuilderRef, PointerVal: TLLVMValueRef, 
+                    Name: cstring): TLLVMValueRef{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMBuildStore*(para1: TLLVMBuilderRef, Val: TLLVMValueRef, 
+                     thePtr: TLLVMValueRef): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildGEP*(B: TLLVMBuilderRef, Pointer: TLLVMValueRef, 
+                   Indices: PLLVMValueRef, NumIndices: cuint, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+  # Casts  
+proc LLVMBuildTrunc*(para1: TLLVMBuilderRef, Val: TLLVMValueRef, 
+                     DestTy: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildZExt*(para1: TLLVMBuilderRef, Val: TLLVMValueRef, 
+                    DestTy: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildSExt*(para1: TLLVMBuilderRef, Val: TLLVMValueRef, 
+                    DestTy: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildFPToUI*(para1: TLLVMBuilderRef, Val: TLLVMValueRef, 
+                      DestTy: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildFPToSI*(para1: TLLVMBuilderRef, Val: TLLVMValueRef, 
+                      DestTy: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildUIToFP*(para1: TLLVMBuilderRef, Val: TLLVMValueRef, 
+                      DestTy: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildSIToFP*(para1: TLLVMBuilderRef, Val: TLLVMValueRef, 
+                      DestTy: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildFPTrunc*(para1: TLLVMBuilderRef, Val: TLLVMValueRef, 
+                       DestTy: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildFPExt*(para1: TLLVMBuilderRef, Val: TLLVMValueRef, 
+                     DestTy: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildPtrToInt*(para1: TLLVMBuilderRef, Val: TLLVMValueRef, 
+                        DestTy: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildIntToPtr*(para1: TLLVMBuilderRef, Val: TLLVMValueRef, 
+                        DestTy: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildBitCast*(para1: TLLVMBuilderRef, Val: TLLVMValueRef, 
+                       DestTy: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+  # Comparisons  
+proc LLVMBuildICmp*(para1: TLLVMBuilderRef, Op: TLLVMIntPredicate, 
+                    LHS: TLLVMValueRef, RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildFCmp*(para1: TLLVMBuilderRef, Op: TLLVMRealPredicate, 
+                    LHS: TLLVMValueRef, RHS: TLLVMValueRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+  # Miscellaneous instructions  
+proc LLVMBuildPhi*(para1: TLLVMBuilderRef, Ty: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildCall*(para1: TLLVMBuilderRef, Fn: TLLVMValueRef, 
+                    Args: PLLVMValueRef, NumArgs: cuint, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildSelect*(para1: TLLVMBuilderRef, IfCond: TLLVMValueRef, 
+                      ThenBranch: TLLVMValueRef, ElseBranch: TLLVMValueRef, 
+                      Name: cstring): TLLVMValueRef{.cdecl, dynlib: llvmdll, 
+    importc.}
+proc LLVMBuildVAArg*(para1: TLLVMBuilderRef, List: TLLVMValueRef, 
+                     Ty: TLLVMTypeRef, Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildExtractElement*(para1: TLLVMBuilderRef, VecVal: TLLVMValueRef, 
+                              Index: TLLVMValueRef, Name: cstring): TLLVMValueRef{.
+    cdecl, dynlib: llvmdll, importc.}
+proc LLVMBuildInsertElement*(para1: TLLVMBuilderRef, VecVal: TLLVMValueRef, 
+                             EltVal: TLLVMValueRef, Index: TLLVMValueRef, 
+                             Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMBuildShuffleVector*(para1: TLLVMBuilderRef, V1: TLLVMValueRef, 
+                             V2: TLLVMValueRef, Mask: TLLVMValueRef, 
+                             Name: cstring): TLLVMValueRef{.cdecl, 
+    dynlib: llvmdll, importc.}
+  #===-- Module providers --------------------------------------------------=== 
+  # Encapsulates the module M in a module provider, taking ownership of the
+  #  module.
+  #  See the constructor llvm: : ExistingModuleProvider: : ExistingModuleProvider.
+  #
+proc LLVMCreateModuleProviderForExistingModule*(M: TLLVMModuleRef): TLLVMModuleProviderRef{.
+    cdecl, dynlib: llvmdll, importc.}
+  # Destroys the module provider MP as well as the contained module.
+  #  See the destructor llvm: : ModuleProvider: : ~ModuleProvider.
+  #
+proc LLVMDisposeModuleProvider*(MP: TLLVMModuleProviderRef){.cdecl, 
+    dynlib: llvmdll, importc.}
+  #===-- Memory buffers ----------------------------------------------------=== 
+proc LLVMCreateMemoryBufferWithContentsOfFile*(Path: cstring, 
+    OutMemBuf: pLLVMMemoryBufferRef, OutMessage: var cstring): int32{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMCreateMemoryBufferWithSTDIN*(OutMemBuf: pLLVMMemoryBufferRef, 
+                                      OutMessage: var cstring): int32{.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMDisposeMemoryBuffer*(MemBuf: TLLVMMemoryBufferRef){.cdecl, 
+    dynlib: llvmdll, importc.}
+proc LLVMWriteBitcodeToFile*(M: TLLVMModuleRef, path: cstring): int{.cdecl, 
+    dynlib: llvmdll, importc.}
+  # Writes a module to the specified path. Returns 0 on success.
+# implementation