changeset 1651:cb960b882ca3 tip

bindings were moved to dsource.org/projects/bindings/
author Moritz Warning <moritzwarning@web.de>
date Thu, 20 May 2010 20:05:03 +0200
parents 40bd4a0d4870
children
files tools/binding/LICENSE.TXT tools/binding/dsss.conf tools/binding/llvm-ext.cpp tools/binding/llvm-opt.cpp tools/binding/llvm-typemonitor.cpp tools/binding/llvm/builder.d tools/binding/llvm/c/Analysis.d tools/binding/llvm/c/BitReader.d tools/binding/llvm/c/BitWriter.d tools/binding/llvm/c/Core.d tools/binding/llvm/c/ExecutionEngine.d tools/binding/llvm/c/Ext.d tools/binding/llvm/c/Target.d tools/binding/llvm/c/transforms/IPO.d tools/binding/llvm/c/transforms/Scalar.d tools/binding/llvm/executionengine.d tools/binding/llvm/llvm.d tools/binding/llvm/type.d tools/binding/llvm/util.d tools/binding/llvmsample1.d tools/binding/llvmsample2.d tools/binding/llvmsample3.d tools/binding/prebuild.sh
diffstat 23 files changed, 0 insertions(+), 3725 deletions(-) [+]
line wrap: on
line diff
--- a/tools/binding/LICENSE.TXT	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,72 +0,0 @@
-==============================================================================
-LLVM Release License
-==============================================================================
-University of Illinois/NCSA
-Open Source License
-
-Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-All rights reserved.
-
-Developed by:
-
-    LLVM Team
-
-    University of Illinois at Urbana-Champaign
-
-    http://llvm.org
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal with
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimers.
-
-    * Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimers in the
-      documentation and/or other materials provided with the distribution.
-
-    * Neither the names of the LLVM Team, University of Illinois at
-      Urbana-Champaign, nor the names of its contributors may be used to
-      endorse or promote products derived from this Software without specific
-      prior written permission.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-SOFTWARE.
-
-==============================================================================
-Copyrights and Licenses for Third Party Software Distributed with LLVM:
-==============================================================================
-The LLVM software contains code written by third parties.  Such software will
-have its own individual LICENSE.TXT file in the directory in which it appears.
-This file will describe the copyrights, license, and restrictions which apply
-to that code.
-
-The disclaimer of warranty in the University of Illinois Open Source License
-applies to all code in the LLVM Distribution, and nothing in any of the
-other licenses gives permission to use the names of the LLVM Team or the
-University of Illinois to endorse or promote products derived from this
-Software.
-
-The following pieces of software have additional or alternate copyrights,
-licenses, and/or restrictions:
-
-Program             Directory
--------             ---------
-System Library      llvm/lib/System
-Compiler Driver     llvm/tools/llvmc
-Autoconf            llvm/autoconf
-                    llvm/projects/ModuleMaker/autoconf
-                    llvm/projects/sample/autoconf
-Boost C++ Libraries llvm/include : docs/BOOST_LICENSE_1_0.txt
-CellSPU backend     llvm/lib/Target/CellSPU/README.txt
-
-
--- a/tools/binding/dsss.conf	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,30 +0,0 @@
-defaulttargets= llvm
-
-[llvm]
-type= library
-prebuild= sh prebuild.sh
-postinstall= install libllvm-c-ext.a $PREFIX/lib
-
-[llvmsample1.d]
-buildflags = libllvm-c-ext.a -llstdc++ \
- -llLLVMCore -llLLVMBitWriter -llLLVMBitReader -llLLVMAnalysis -llLLVMTarget \
- -llLLVMTransformUtils -llLLVMScalarOpts -llLLVMipa -llLLVMipo \
- -llLLVMInstrumentation -llLLVMSystem -llLLVMSupport -lldl
-
-[llvmsample2.d]
-buildflags = libllvm-c-ext.a -llstdc++ \
- -llLLVMCore -llLLVMBitWriter -llLLVMBitReader -llLLVMAnalysis -llLLVMTarget \
- -llLLVMTransformUtils -llLLVMScalarOpts -llLLVMipa -llLLVMipo \
- -llLLVMInstrumentation -llLLVMSystem -llLLVMSupport -lldl
-
-[llvmsample3.d]
-buildflags = libllvm-c-ext.a -llstdc++ \
- -llLLVMCore -llLLVMBitWriter -llLLVMBitReader -llLLVMAnalysis -llLLVMTarget \
- -llLLVMTransformUtils -llLLVMScalarOpts -llLLVMipa -llLLVMipo \
- -llLLVMInstrumentation -llLLVMSystem -llLLVMSupport -lldl
-
-[llvmsample4.d]
-buildflags = libllvm-c-ext.a -llstdc++ \
- -llLLVMCore -llLLVMBitWriter -llLLVMBitReader -llLLVMAnalysis -llLLVMTarget \
- -llLLVMTransformUtils -llLLVMScalarOpts -llLLVMipa -llLLVMipo \
- -llLLVMInstrumentation -llLLVMSystem -llLLVMSupport -lldl
--- a/tools/binding/llvm-ext.cpp	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,87 +0,0 @@
-// Extension of the LLVM C interface for use with D, some things in the
-// LLVM 2.2 release are kind sparse or even broken...
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-#ifndef D11_LLVMCEXT_H
-#define D11_LLVMCEXT_H
-
-#include "llvm/Type.h"
-#include "llvm/Constants.h"
-#include "llvm/Support/CFG.h"
-#include "llvm/Target/TargetData.h"
-#include "llvm-c/Core.h"
-
-#include <sstream>
-#include <cstring>
-
-using namespace llvm;
-using namespace std;
-
-extern "C"
-{
-
-// we need to be able to erase an instruction from its parent
-void LLVMEraseFromParent(LLVMValueRef I) {
-    unwrap<Instruction>(I)->eraseFromParent();
-}
-
-// we need to be able to check if a basic block is terminated
-int LLVMIsTerminated(LLVMBasicBlockRef BB) {
-    return (unwrap(BB)->getTerminator() != NULL);
-}
-
-// we need to be able to check if a basic block has any predecessors
-int LLVMHasPredecessors(LLVMBasicBlockRef BB) {
-    BasicBlock* B = unwrap(BB);
-    return (pred_begin(B) != pred_end(B));
-}
-
-// we need to be able to check if a basic block is empty
-int LLVMIsBasicBlockEmpty(LLVMBasicBlockRef BB) {
-    return unwrap(BB)->empty();
-}
-
-// we need to be able to replace all uses of V with W
-void LLVMReplaceAllUsesWith(LLVMValueRef V, LLVMValueRef W) {
-    unwrap<Value>(V)->replaceAllUsesWith(unwrap<Value>(W));
-}
-
-// sometimes it's nice to be able to dump a type, not only values...
-void LLVMDumpType(LLVMTypeRef T) {
-    unwrap(T)->dump();
-}
-
-LLVMValueRef LLVMGetOrInsertFunction(LLVMModuleRef M, char* Name, LLVMTypeRef Type) {
-    return wrap(unwrap(M)->getOrInsertFunction(Name, unwrap<FunctionType>(Type)));
-}
-
-// being able to determine the "kind" of a value is really useful
-unsigned LLVMGetValueKind(LLVMValueRef Value) {
-    return unwrap(Value)->getValueID();
-}
-
-char* LLVMValueToString(LLVMValueRef v) {
-    stringstream ss;
-    unwrap(v)->print(ss);
-    return strdup(ss.str().c_str());
-}
-
-char* LLVMTypeToString(LLVMTypeRef ty) {
-    stringstream ss;
-    unwrap(ty)->print(ss);
-    return strdup(ss.str().c_str());
-}
-
-LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, char* Name) {
-    return wrap(unwrap(M)->getTypeByName(Name));
-}
-
-int LLVMIsTypeAbstract(LLVMTypeRef T) {
-    return unwrap(T)->isAbstract();
-}
-
-} // extern "C"
-
-#endif
--- a/tools/binding/llvm-opt.cpp	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,75 +0,0 @@
-// Optimizer functionality for the LLVM D binding.
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-#include "llvm/PassManager.h"
-#include "llvm/LinkAllPasses.h"
-#include "llvm/Analysis/LoopPass.h"
-#include "llvm/Target/TargetData.h"
-#include "llvm-c/Core.h"
-
-using namespace llvm;
-
-extern "C" {
-
-void LLVMOptimizeModule(LLVMModuleRef M, int doinline)
-{
-    Module* m = unwrap(M);
-
-    PassManager pm;
-    pm.add(new TargetData(m));
-
-    //pm.add(createStripDeadPrototypesPass());
-    pm.add(createGlobalDCEPass());
-
-    pm.add(createRaiseAllocationsPass());
-    pm.add(createCFGSimplificationPass());
-    pm.add(createPromoteMemoryToRegisterPass());
-    pm.add(createGlobalOptimizerPass());
-    pm.add(createGlobalDCEPass());
-
-    pm.add(createIPConstantPropagationPass());
-    pm.add(createDeadArgEliminationPass());
-    pm.add(createInstructionCombiningPass());
-    pm.add(createCFGSimplificationPass());
-    pm.add(createPruneEHPass());
-
-    if (doinline)
-        pm.add(createFunctionInliningPass());
-
-    pm.add(createArgumentPromotionPass());
-    pm.add(createTailDuplicationPass());
-    pm.add(createInstructionCombiningPass());
-    pm.add(createCFGSimplificationPass());
-    pm.add(createScalarReplAggregatesPass());
-    pm.add(createInstructionCombiningPass());
-    pm.add(createCondPropagationPass());
-
-    pm.add(createTailCallEliminationPass());
-    pm.add(createCFGSimplificationPass());
-    pm.add(createReassociatePass());
-    pm.add(createLoopRotatePass());
-    pm.add(createLICMPass());
-    pm.add(createLoopUnswitchPass());
-    pm.add(createInstructionCombiningPass());
-    pm.add(createIndVarSimplifyPass());
-    pm.add(createLoopUnrollPass());
-    pm.add(createInstructionCombiningPass());
-    pm.add(createGVNPass());
-    pm.add(createSCCPPass());
-
-    pm.add(createInstructionCombiningPass());
-    pm.add(createCondPropagationPass());
-
-    pm.add(createDeadStoreEliminationPass());
-    pm.add(createAggressiveDCEPass());
-    pm.add(createCFGSimplificationPass());
-    pm.add(createSimplifyLibCallsPass());
-    pm.add(createDeadTypeEliminationPass());
-    pm.add(createConstantMergePass());
-
-    pm.run(*m);
-}
-
-}
--- a/tools/binding/llvm-typemonitor.cpp	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,46 +0,0 @@
-/// Support for callbacks when an abstract type becomes more concrete.
-
-#include "llvm/Support/Streams.h"
-#include "llvm/Type.h"
-#include "llvm-c/Core.h"
-
-using namespace llvm;
-
-extern "C" typedef int (*RefineCallback)(void *handle, LLVMTypeRef newT);
-
-class TypeMonitor : AbstractTypeUser {
-    void *handle_;
-    RefineCallback callback_;
-    
-    void onRefineType(const Type* oldT, const Type* newT) {
-        callback_(handle_, wrap(newT));
-        oldT->removeAbstractTypeUser(this);
-        delete this;
-    }
-    
-    public:
-    
-    TypeMonitor(Type* T, void *handle, RefineCallback callback)
-    : handle_(handle), callback_(callback) {
-        T->addAbstractTypeUser(this);
-    }
-    
-    virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy) {
-        onRefineType(OldTy, NewTy);
-    }
-    
-    virtual void typeBecameConcrete(const DerivedType *AbsTy) {
-        onRefineType(AbsTy, AbsTy);
-    }
-    
-    virtual void dump() const {
-        cerr << "<TypeMonitor>";
-    }
-};
-
-extern "C" void LLVMRegisterAbstractTypeCallback(LLVMTypeRef T,
-                                                 void *handle,
-                                                 RefineCallback callback)
-{
-    new TypeMonitor(unwrap(T), handle, callback);
-}
--- a/tools/binding/llvm/builder.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,202 +0,0 @@
-// Written in the D programming language by Tomas Lindquist Olsen 2008
-// Binding of llvm.c.Core builder for D.
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-module llvm.builder;
-
-import llvm.c.Core;
-import llvm.c.Ext;
-
-import llvm.llvm;
-import llvm.util;
-
-private
-{
-    template Build_NoArgs_Mixin(char[] N) {
-       const Build_NoArgs_Mixin = "
-       Value build"~N~"() {
-           return new Value(LLVMBuild"~N~"(builder));
-       }
-       ";
-    }
-
-    template Build_Mixin(char[] NAME, char[] ARGS, char[] VALUES) {
-       const Build_Mixin = "
-       Value build"~NAME~"("~ARGS~") {
-           return new Value(LLVMBuild"~NAME~"(builder, "~VALUES~"));
-       }
-       ";
-       static assert(ARGS != "");
-       static assert(VALUES != "");
-    }
-
-    // unnamed
-    template Build_Value(char[] N) {
-       const Build_Value = Build_Mixin!(N, "Value v", `v.value`);
-    }
-    template Build_Value_Value(char[] N) {
-       const Build_Value_Value = Build_Mixin!(N, "Value v, Value w", `v.value, w.value`);
-    }
-    template Build_BB(char[] N) {
-       const Build_BB = Build_Mixin!(N, "BasicBlock b", `b.bb`);
-    }
-    template Build_Value_BB_BB(char[] N) {
-       const Build_Value_BB_BB = Build_Mixin!(N, "Value v, BasicBlock b1, BasicBlock b2", `v.value, b1.bb, b2.bb`);
-    }
-    template Build_Value_BB_uint(char[] N) {
-       const Build_Value_BB_uint = Build_Mixin!(N, "Value v, BasicBlock b, uint n", `v.value, b.bb, n`);
-    }
-
-    // named
-    template Build_Named_Mixin(char[] NAME, char[] ARGS, char[] VALUES) {
-       const Build_Named_Mixin = Build_Mixin!(NAME, ARGS~", char[] name", VALUES~`, to_stringz(name)`);
-    }
-
-    template Build_Type_Name(char[] N) {
-       const Build_Type_Name = Build_Named_Mixin!(N, "Type t", `t.ll`);
-    }
-    template Build_Value_Name(char[] N) {
-       const Build_Value_Name = Build_Named_Mixin!(N, "Value v", `v.value`);
-    }
-    template Build_Type_Value_Name(char[] N) {
-       const Build_Type_Value_Name = Build_Named_Mixin!(N, "Type t, Value v", `t.ll, v.value`);
-    }
-    template Build_Value_Type_Name(char[] N) {
-       const Build_Value_Type_Name = Build_Named_Mixin!(N, "Value v, Type t", `v.value, t.ll`);
-    }
-    template Build_Value_Value_Name(char[] N) {
-       const Build_Value_Value_Name = Build_Named_Mixin!(N, "Value a, Value b", `a.value, b.value`);
-    }
-    template Build_Value_Value_Value_Name(char[] N) {
-       const Build_Value_Value_Value_Name = Build_Named_Mixin!(N, "Value a, Value b, Value c", `a.value, b.value, c.value`);
-    }
-    template Build_Value_uint_Name(char[] N) {
-        const Build_Value_uint_Name = Build_Named_Mixin!(N, "Value a, uint n", `a.value, n`);
-    }
-    template Build_Value_Value_uint_Name(char[] N) {
-       const Build_Value_Value_uint_Name = Build_Named_Mixin!(N, "Value a, Value b, uint n", `a.value, b.value, n`);
-    }
-    template Build_Cmp(char[] PRED, char[] N) {
-       const Build_Cmp = Build_Named_Mixin!(N, ""~PRED~"Predicate p, Value l, Value r", `p, l.value, r.value`);
-    }
-
-    template StringDistribute(alias T, U...)
-    {
-        static if (!U.length)
-            const char[] StringDistribute="";
-        else
-            const char[] StringDistribute = T!(U[0]) ~ StringDistribute!(T, U[1..$]);
-    }
-}
-
-///
-class Builder
-{
-    ///
-    private LLVMBuilderRef builder;
-    ///
-    this()
-    {
-        builder = LLVMCreateBuilder();
-    }
-    ///
-    void dispose()
-    {
-        LLVMDisposeBuilder(builder);
-        builder = null;
-    }
-    ///
-    ~this()
-    {
-        // safe because builder isn't on the GC heap and isn't exposed.
-        dispose();
-    }
-    ///
-    void positionBefore(Value v)
-    {
-        assert(builder !is null);
-        LLVMPositionBuilderBefore(builder, v.value);
-    }
-    ///
-    void positionAtEnd(BasicBlock bb)
-    {
-        assert(builder !is null);
-        LLVMPositionBuilderAtEnd(builder, bb.bb);
-    }
-    ///
-    void positionAtStart(BasicBlock bb)
-    {
-        assert(builder !is null);
-        LLVMPositionBuilderBefore(builder, LLVMGetFirstInstruction(bb.bb));
-    }
-    ///
-    BasicBlock getInsertBlock()
-    {
-        return new BasicBlock(LLVMGetInsertBlock(builder));
-    }
-
-    ///
-    mixin(StringDistribute!(Build_NoArgs_Mixin, "RetVoid", "Unwind", "Unreachable"));
-    mixin(Build_BB!("Br"));
-    mixin(Build_Value_BB_BB!("CondBr"));
-    mixin(Build_Value_BB_uint!("Switch"));
-    ///
-    mixin(StringDistribute!(Build_Value, "Ret", "Free"));
-    ///
-    mixin(Build_Value_Value!("Store"));
-    ///
-    mixin(StringDistribute!(Build_Value_Value_Name,
-        "Add","Sub","Mul","UDiv","SDiv","FDiv","URem","SRem","FRem",
-        "Shl","LShr","AShr","And","Or","Xor",
-        "ExtractElement"
-    ));
-    ///
-    mixin(StringDistribute!(Build_Value_Name, "Neg","Not", "Load"));
-    ///
-    mixin(StringDistribute!(Build_Value_Type_Name,
-        "Trunc","SExt","ZExt","FPTrunc","FPExt",
-        "UIToFP","SIToFP","FPToUI","FPToSI",
-        "PtrToInt","IntToPtr","BitCast",
-        "VAArg"
-    ));
-    ///
-    mixin(Build_Cmp!("Int","ICmp"));
-    ///
-    mixin(Build_Cmp!("Real","FCmp"));
-    ///
-    mixin(StringDistribute!(Build_Type_Name,
-        "Phi", "Malloc", "Alloca"
-    ));
-    ///
-    mixin(StringDistribute!(Build_Type_Value_Name,
-        "ArrayMalloc", "ArrayAlloca"
-    ));
-    ///
-    mixin(StringDistribute!(Build_Value_Value_Value_Name,
-        "Select", "InsertElement", "ShuffleVector"
-    ));
-    ///
-    mixin(Build_Value_uint_Name!("ExtractValue"));
-    ///
-    mixin(Build_Value_Value_uint_Name!("InsertValue"));
-    ///
-    Value buildCall(Value fn, Value[] args, char[] name) {
-        auto llargs = new LLVMValueRef[args.length];
-        foreach(i,a; args) llargs[i] = a.value;
-        return new Value(LLVMBuildCall(builder, fn.value, llargs.ptr, llargs.length, to_stringz(name)));
-    }
-    ///
-    Value buildGEP(Value ptr, Value[] indices, char[] name) {
-        auto llindices = new LLVMValueRef[indices.length];
-        foreach(i,idx; indices) llindices[i] = idx.value;
-        return new Value(LLVMBuildGEP(builder, ptr.value, llindices.ptr, llindices.length, to_stringz(name)));
-    }
-    ///
-    Value buildInvoke(Value fn, Value[] args, BasicBlock thenbb, BasicBlock catchbb, char[] name) {
-        auto llargs = new LLVMValueRef[args.length];
-        foreach(i,a; args) llargs[i] = a.value;
-        return new Value(LLVMBuildInvoke(builder, fn.value, llargs.ptr, llargs.length, thenbb.bb, catchbb.bb, to_stringz(name)));
-    }
-}
--- a/tools/binding/llvm/c/Analysis.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,42 +0,0 @@
-// Converted to the D programming language by Tomas Lindquist Olsen 2008
-// Original file header:
-/*===-- llvm-c/Analysis.h - Analysis Library C Interface --------*- C++ -*-===*\
-|*                                                                            *|
-|*                     The LLVM Compiler Infrastructure                       *|
-|*                                                                            *|
-|* This file is distributed under the University of Illinois Open Source      *|
-|* License. See LICENSE.TXT for details.                                      *|
-|*                                                                            *|
-|*===----------------------------------------------------------------------===*|
-|*                                                                            *|
-|* This header declares the C interface to libLLVMAnalysis.a, which           *|
-|* implements various analyses of the LLVM IR.                                *|
-|*                                                                            *|
-|* Many exotic languages can interoperate with C code but have a harder time  *|
-|* with C++ due to name mangling. So in addition to C, this interface enables *|
-|* tools written in such languages.                                           *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
-
-module llvm.c.Analysis;
-
-import llvm.c.Core;
-
-extern(C):
-
-enum LLVMVerifierFailureAction {
-  AbortProcess, /* verifier will print to stderr and abort() */
-  PrintMessage, /* verifier will print to stderr and return 1 */
-  ReturnStatus  /* verifier will just return 1 */
-}
-
-
-/* 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. */
-int LLVMVerifyModule(LLVMModuleRef M, LLVMVerifierFailureAction Action,
-                     char **OutMessage);
-
-/* Verifies that a single function is valid, taking the specified action. Useful
-   for debugging. */
-int LLVMVerifyFunction(LLVMValueRef Fn, LLVMVerifierFailureAction Action);
--- a/tools/binding/llvm/c/BitReader.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,38 +0,0 @@
-// Converted to the D programming language by Tomas Lindquist Olsen 2008
-// Original file header:
-/*===-- llvm-c/BitReader.h - BitReader Library C Interface ------*- C++ -*-===*\
-|*                                                                            *|
-|*                     The LLVM Compiler Infrastructure                       *|
-|*                                                                            *|
-|* This file is distributed under the University of Illinois Open Source      *|
-|* License. See LICENSE.TXT for details.                                      *|
-|*                                                                            *|
-|*===----------------------------------------------------------------------===*|
-|*                                                                            *|
-|* This header declares the C interface to libLLVMBitReader.a, which          *|
-|* implements input of the LLVM bitcode format.                               *|
-|*                                                                            *|
-|* Many exotic languages can interoperate with C code but have a harder time  *|
-|* with C++ due to name mangling. So in addition to C, this interface enables *|
-|* tools written in such languages.                                           *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
-
-module llvm.c.BitReader;
-
-import llvm.c.Core;
-
-extern(C):
-
-/* 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. */
-int LLVMParseBitcode(LLVMMemoryBufferRef MemBuf,
-                     LLVMModuleRef *OutModule, char **OutMessage);
-
-/* 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. */
-int LLVMGetBitcodeModuleProvider(LLVMMemoryBufferRef MemBuf,
-                                 LLVMModuleProviderRef *OutMP,
-                                 char **OutMessage);
--- a/tools/binding/llvm/c/BitWriter.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,33 +0,0 @@
-// Converted to the D programming language by Tomas Lindquist Olsen 2008
-// Original file header:
-/*===-- llvm-c/BitWriter.h - BitWriter Library C Interface ------*- C++ -*-===*\
-|*                                                                            *|
-|*                     The LLVM Compiler Infrastructure                       *|
-|*                                                                            *|
-|* This file is distributed under the University of Illinois Open Source      *|
-|* License. See LICENSE.TXT for details.                                      *|
-|*                                                                            *|
-|*===----------------------------------------------------------------------===*|
-|*                                                                            *|
-|* This header declares the C interface to libLLVMBitWriter.a, which          *|
-|* implements output of the LLVM bitcode format.                              *|
-|*                                                                            *|
-|* Many exotic languages can interoperate with C code but have a harder time  *|
-|* with C++ due to name mangling. So in addition to C, this interface enables *|
-|* tools written in such languages.                                           *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
-
-module llvm.c.BitWriter;
-
-import llvm.c.Core;
-
-extern(C):
-
-/*===-- Operations on modules ---------------------------------------------===*/
-
-/** Writes a module to an open file descriptor. Returns 0 on success. */
-int LLVMWriteBitcodeToFileHandle(LLVMModuleRef M, int Handle);
-
-/** Writes a module to the specified path. Returns 0 on success. */
-int LLVMWriteBitcodeToFile(LLVMModuleRef M, /*const*/ char *Path);
--- a/tools/binding/llvm/c/Core.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,696 +0,0 @@
-// Converted to the D programming language by Tomas Lindquist Olsen 2008
-//                                        and Frits van Bommel 2008
-// Original file header:
-/*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\
-|*                                                                            *|
-|*                     The LLVM Compiler Infrastructure                       *|
-|*                                                                            *|
-|* This file is distributed under the University of Illinois Open Source      *|
-|* License. See LICENSE.TXT for details.                                      *|
-|*                                                                            *|
-|*===----------------------------------------------------------------------===*|
-|*                                                                            *|
-|* This header declares the C interface to libLLVMCore.a, which implements    *|
-|* the LLVM intermediate representation.                                      *|
-|*                                                                            *|
-|* LLVM uses a polymorphic type hierarchy which C cannot represent, therefore *|
-|* parameters must be passed as base types. Despite the declared types, most  *|
-|* of the functions provided operate only on branches of the type hierarchy.  *|
-|* The declared parameter names are descriptive and specify which type is     *|
-|* required. Additionally, each type hierarchy is documented along with the   *|
-|* functions that operate upon it. For more detail, refer to LLVM's C++ code. *|
-|* If in doubt, refer to Core.cpp, which performs paramter downcasts in the   *|
-|* form unwrap<RequiredType>(Param).                                          *|
-|*                                                                            *|
-|* Many exotic languages can interoperate with C code but have a harder time  *|
-|* with C++ due to name mangling. So in addition to C, this interface enables *|
-|* tools written in such languages.                                           *|
-|*                                                                            *|
-|* When included into a C++ source file, also declares 'wrap' and 'unwrap'    *|
-|* helpers to perform opaque reference<-->pointer conversions. These helpers  *|
-|* are shorter and more tightly typed than writing the casts by hand when     *|
-|* authoring bindings. In assert builds, they will do runtime type checking.  *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
-module llvm.c.Core;
-
-extern(C):
-
-/**
- * The top-level container for all other LLVM Intermediate Representation (IR)
- * objects. See the llvm::Module class.
- */
-typedef void* LLVMModuleRef;
-
-/**
- * Each value in the LLVM IR has a type, an instance of [lltype]. See the
- * llvm::Type class.
- */
-typedef void* LLVMTypeRef;
-
-/**
- * When building recursive types using [refine_type], [lltype] values may become
- * invalid; use [lltypehandle] to resolve this problem. See the
- * llvm::AbstractTypeHolder] class.
- */
-typedef void* LLVMTypeHandleRef;
-
-typedef void* LLVMValueRef;
-typedef void* LLVMBasicBlockRef;
-typedef void* LLVMBuilderRef;
-
-/* Used to provide a module to JIT or interpreter.
- * See the llvm::ModuleProvider class.
- */
-typedef void* LLVMModuleProviderRef;
-
-/* Used to provide a module to JIT or interpreter.
- * See the llvm::MemoryBuffer class.
- */
-typedef void* LLVMMemoryBufferRef;
-
-/** See the llvm::PassManagerBase class. */
-typedef void* LLVMPassManagerRef;
-
-enum LLVMAttribute {
-    ZExt       = 1<<0,
-    SExt       = 1<<1,
-    NoReturn   = 1<<2,
-    InReg      = 1<<3,
-    StructRet  = 1<<4,
-    NoUnwind   = 1<<5,
-    NoAlias    = 1<<6,
-    ByVal      = 1<<7,
-    Nest       = 1<<8,
-    ReadNone   = 1<<9,
-    ReadOnly   = 1<<10,
-    NoInline   = 1<<11,
-    AlwaysInline    = 1<<12,
-    OptimizeForSize = 1<<13,
-    StackProtect    = 1<<14,
-    StackProtectReq = 1<<15,
-    NoCapture  = 1<<21,
-    NoRedZone  = 1<<22,
-    NoImplicitFloat = 1<<23,
-    Naked      = 1<<24
-}
-
-enum LLVMTypeKind {
-    Void,        /**< type with no size */
-    Float,       /**< 32 bit floating point type */
-    Double,      /**< 64 bit floating point type */
-    X86_FP80,    /**< 80 bit floating point type (X87) */
-    FP128,       /**< 128 bit floating point type (112-bit mantissa)*/
-    PPC_FP128,   /**< 128 bit floating point type (two 64-bits) */
-    Label,       /**< Labels */
-    Integer,     /**< Arbitrary bit width integers */
-    Function,    /**< Functions */
-    Struct,      /**< Structures */
-    Array,       /**< Arrays */
-    Pointer,     /**< Pointers */
-    Opaque,      /**< Opaque: type with unknown structure */
-    Vector,      /**< SIMD 'packed' format, or other vector type */
-    Metadata     /**< Metadata */
-}
-
-enum LLVMLinkage {
-    External,    /**< Externally visible function */
-    AvailableExternally,
-    LinkOnceAny, /**< Keep one copy of function when linking (inline)*/
-    LinkOnceODR, /**< Same, but only replaced by something
-                                equivalent. */
-    WeakAny,     /**< Keep one copy of function when linking (weak) */
-    WeakODR,     /**< Same, but only replaced by something
-                                equivalent. */
-    Appending,   /**< Special purpose, only applies to global arrays */
-    Internal,    /**< Rename collisions when linking (static
-                                functions) */
-    Private,     /**< Like Internal, but omit from symbol table */
-    DLLImport,   /**< Function to be imported from DLL */
-    DLLExport,   /**< Function to be accessible from DLL */
-    ExternalWeak,/**< ExternalWeak linkage description */
-    Ghost,       /**< Stand-in functions for streaming fns from
-                                bitcode */
-    Common,      /**< Tentative definitions */
-    LinkerPrivate /**< Like Private, but linker removes. */
-}
-
-enum LLVMVisibility {
-  Default,  /**< The GV is visible */
-  Hidden,   /**< The GV is hidden */
-  Protected/**< The GV is protected */
-}
-
-enum LLVMCallConv {
-  C          = 0,
-  Fast       = 8,
-  Cold       = 9,
-  X86Stdcall = 64,
-  X86Fastcall= 65
-}
-
-enum LLVMIntPredicate {
-  EQ = 32, /**< equal */
-  NE,      /**< not equal */
-  UGT,     /**< uint greater than */
-  UGE,     /**< uint greater or equal */
-  ULT,     /**< uint less than */
-  ULE,     /**< uint less or equal */
-  SGT,     /**< signed greater than */
-  SGE,     /**< signed greater or equal */
-  SLT,     /**< signed less than */
-  SLE      /**< signed less or equal */
-}
-
-enum LLVMRealPredicate {
-  False,          /**< Always false (always folded) */
-  OEQ,            /**< True if ordered and equal */
-  OGT,            /**< True if ordered and greater than */
-  OGE,            /**< True if ordered and greater than or equal */
-  OLT,            /**< True if ordered and less than */
-  OLE,            /**< True if ordered and less than or equal */
-  ONE,            /**< True if ordered and operands are unequal */
-  ORD,            /**< True if ordered (no nans) */
-  UNO,            /**< True if unordered: isnan(X) | isnan(Y) */
-  UEQ,            /**< True if unordered or equal */
-  UGT,            /**< True if unordered or greater than */
-  UGE,            /**< True if unordered, greater than, or equal */
-  ULT,            /**< True if unordered or less than */
-  ULE,            /**< True if unordered, less than, or equal */
-  UNE,            /**< True if unordered or not equal */
-  True            /**< Always true (always folded) */
-}
-
-/*===-- Error handling ----------------------------------------------------===*/
-
-void LLVMDisposeMessage(char *Message);
-
-
-/*===-- Modules -----------------------------------------------------------===*/
-
-/* Create and destroy modules. */
-/** See llvm::Module::Module. */
-LLVMModuleRef LLVMModuleCreateWithName(/*const*/ char *ModuleID);
-
-/** See llvm::Module::~Module. */
-void LLVMDisposeModule(LLVMModuleRef M);
-
-/** Data layout. See Module::getDataLayout. */
-/*const*/ char *LLVMGetDataLayout(LLVMModuleRef M);
-void LLVMSetDataLayout(LLVMModuleRef M, /*const*/ char *DataLayout);
-
-/** Target triple. See Module::getTargetTriple. */
-/*const*/ char *LLVMGetTarget(LLVMModuleRef M);
-void LLVMSetTarget(LLVMModuleRef M, /*const*/ char *Triple);
-
-/** See Module::addTypeName. */
-int LLVMAddTypeName(LLVMModuleRef M, /*const*/ char *Name, LLVMTypeRef Ty);
-void LLVMDeleteTypeName(LLVMModuleRef M, /*const*/ char *Name);
-
-/** See Module::dump. */
-void LLVMDumpModule(LLVMModuleRef M);
-
-/*===-- 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
- */
-
-LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty);
-
-/* Operations on integer types */
-LLVMTypeRef LLVMInt1Type();
-LLVMTypeRef LLVMInt8Type();
-LLVMTypeRef LLVMInt16Type();
-LLVMTypeRef LLVMInt32Type();
-LLVMTypeRef LLVMInt64Type();
-LLVMTypeRef LLVMIntType(uint NumBits);
-uint LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy);
-
-/* Operations on real types */
-LLVMTypeRef LLVMFloatType();
-LLVMTypeRef LLVMDoubleType();
-LLVMTypeRef LLVMX86FP80Type();
-LLVMTypeRef LLVMFP128Type();
-LLVMTypeRef LLVMPPCFP128Type();
-
-/* Operations on function types */
-LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
-                             LLVMTypeRef *ParamTypes, uint ParamCount,
-                             int IsVarArg);
-int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
-LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
-uint LLVMCountParamTypes(LLVMTypeRef FunctionTy);
-void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest);
-
-/* Operations on struct types */
-LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, uint ElementCount,
-                           int Packed);
-uint LLVMCountStructElementTypes(LLVMTypeRef StructTy);
-void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest);
-int LLVMIsPackedStruct(LLVMTypeRef StructTy);
-
-/* Operations on array, pointer, and vector types (sequence types) */
-LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, uint ElementCount);
-LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, uint AddressSpace);
-LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, uint ElementCount);
-
-LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty);
-uint LLVMGetArrayLength(LLVMTypeRef ArrayTy);
-uint LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
-uint LLVMGetVectorSize(LLVMTypeRef VectorTy);
-
-/* Operations on other types */
-LLVMTypeRef LLVMVoidType();
-LLVMTypeRef LLVMLabelType();
-LLVMTypeRef LLVMOpaqueType();
-
-/* Operations on type handles */
-LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy);
-void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy);
-LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle);
-void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
-
-
-/*===-- 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 */
-LLVMTypeRef LLVMTypeOf(LLVMValueRef Val);
-/*const*/ char *LLVMGetValueName(LLVMValueRef Val);
-void LLVMSetValueName(LLVMValueRef Val, /*const*/ char *Name);
-void LLVMDumpValue(LLVMValueRef Val);
-
-/* Operations on constants of any type */
-LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */
-LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */
-LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
-int LLVMIsConstant(LLVMValueRef Val);
-int LLVMIsNull(LLVMValueRef Val);
-int LLVMIsUndef(LLVMValueRef Val);
-
-/* Operations on scalar constants */
-LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, ulong N,
-                          int SignExtend);
-LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, /*const*/ char *Text,
-                                  ubyte Radix);
-LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, /*const*/ char *Text,
-                                         uint SLen, ubyte Radix);
-LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N);
-LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, /*const*/ char *Text);
-LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, /*const*/ char *Text,
-                                          uint SLen);
-
-/* Operations on composite constants */
-LLVMValueRef LLVMConstString(/*const*/ char *Str, uint Length,
-                             int DontNullTerminate);
-LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
-                            LLVMValueRef *ConstantVals, uint Length);
-LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, uint Count,
-                             int packed);
-LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, uint Size);
-
-/* Constant expressions */
-LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty);
-LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal);
-LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
-LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
-                           LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
-                           LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal,
-                          LLVMValueRef *ConstantIndices, uint NumIndices);
-LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
-LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
-LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
-LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
-LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
-LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
-LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
-LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
-LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
-LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
-LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
-LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType);
-LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition,
-                             LLVMValueRef ConstantIfTrue,
-                             LLVMValueRef ConstantIfFalse);
-LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
-                                     LLVMValueRef IndexConstant);
-LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
-                                    LLVMValueRef ElementValueConstant,
-                                    LLVMValueRef IndexConstant);
-LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
-                                    LLVMValueRef VectorBConstant,
-                                    LLVMValueRef MaskConstant);
-LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, uint *IdxList,
-                                   uint NumIdx);
-LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant,
-                                  LLVMValueRef ElementValueConstant,
-                                  uint *IdxList, uint NumIdx);
-
-/* Operations on global variables, functions, and aliases (globals) */
-LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
-int LLVMIsDeclaration(LLVMValueRef Global);
-LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
-void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
-/*const*/ char *LLVMGetSection(LLVMValueRef Global);
-void LLVMSetSection(LLVMValueRef Global, /*const*/ char *Section);
-LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
-void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
-uint LLVMGetAlignment(LLVMValueRef Global);
-void LLVMSetAlignment(LLVMValueRef Global, uint Bytes);
-
-/* Operations on global variables */
-LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, /*const*/ char *Name);
-LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, /*const*/ char *Name);
-LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
-LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
-LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
-LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
-void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
-LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
-void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
-int LLVMIsThreadLocal(LLVMValueRef GlobalVar);
-void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal);
-int LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
-void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant);
-
-/* Operations on functions */
-LLVMValueRef LLVMAddFunction(LLVMModuleRef M, /*const*/ char *Name,
-                             LLVMTypeRef FunctionTy);
-LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, /*const*/ char *Name);
-LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M);
-LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M);
-LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn);
-LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn);
-void LLVMDeleteFunction(LLVMValueRef Fn);
-uint LLVMGetIntrinsicID(LLVMValueRef Fn);
-uint LLVMGetFunctionCallConv(LLVMValueRef Fn);
-void LLVMSetFunctionCallConv(LLVMValueRef Fn, uint CC);
-/*const*/ char *LLVMGetGC(LLVMValueRef Fn);
-void LLVMSetGC(LLVMValueRef Fn, /*const*/ char *Name);
-void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
-void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA);
-
-/* Operations on parameters */
-uint LLVMCountParams(LLVMValueRef Fn);
-void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params);
-LLVMValueRef LLVMGetParam(LLVMValueRef Fn, uint Index);
-LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst);
-LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn);
-LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn);
-LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg);
-LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg);
-void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA);
-void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA);
-void LLVMSetParamAlignment(LLVMValueRef Arg, uint alignm);
-
-
-/* Operations on basic blocks */
-LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb);
-int LLVMValueIsBasicBlock(LLVMValueRef Val);
-LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
-LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB);
-uint LLVMCountBasicBlocks(LLVMValueRef Fn);
-void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks);
-LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn);
-LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn);
-LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB);
-LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB);
-LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn);
-LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, /*const*/ char *Name);
-LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB,
-                                       /*const*/ char *Name);
-void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB);
-
-/* Operations on instructions */
-LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst);
-LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB);
-LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB);
-LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst);
-LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst);
-
-/* Operations on call sites */
-void LLVMSetInstructionCallConv(LLVMValueRef Instr, uint CC);
-uint LLVMGetInstructionCallConv(LLVMValueRef Instr);
-void LLVMAddInstrAttribute(LLVMValueRef Instr, uint index, LLVMAttribute);
-void LLVMRemoveInstrAttribute(LLVMValueRef Instr, uint index, LLVMAttribute);
-void LLVMSetInstrParamAlignment(LLVMValueRef Instr, uint index, uint alignm);
-
-/* Operations on call instructions (only) */
-int LLVMIsTailCall(LLVMValueRef CallInst);
-void LLVMSetTailCall(LLVMValueRef CallInst, int IsTailCall);
-
-/* Operations on phi nodes */
-void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
-                     LLVMBasicBlockRef *IncomingBlocks, uint Count);
-uint LLVMCountIncoming(LLVMValueRef PhiNode);
-LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, uint Index);
-LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, uint Index);
-
-/*===-- Instruction builders ----------------------------------------------===*/
-
-/* An instruction builder represents a point within a basic block, and is the
- * exclusive means of building instructions using the C interface.
- */
-
-LLVMBuilderRef LLVMCreateBuilder();
-void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
-                         LLVMValueRef Instr);
-void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr);
-void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block);
-LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder);
-void LLVMDisposeBuilder(LLVMBuilderRef Builder);
-
-/* Terminators */
-LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef);
-LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V);
-LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
-LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
-                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
-LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
-                             LLVMBasicBlockRef Else, uint NumCases);
-LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
-                             LLVMValueRef *Args, uint NumArgs,
-                             LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
-                             /*const*/ char *Name);
-LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef);
-LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
-
-/* Add a case to the switch instruction */
-void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
-                 LLVMBasicBlockRef Dest);
-
-/* Arithmetic */
-LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
-                          /*const*/ char *Name);
-LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
-                          /*const*/ char *Name);
-LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
-                          /*const*/ char *Name);
-LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
-                           /*const*/ char *Name);
-LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
-                           /*const*/ char *Name);
-LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
-                           /*const*/ char *Name);
-LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
-                           /*const*/ char *Name);
-LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
-                           /*const*/ char *Name);
-LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
-                           /*const*/ char *Name);
-LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
-                           /*const*/ char *Name);
-LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
-                           /*const*/ char *Name);
-LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
-                           /*const*/ char *Name);
-LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
-                          /*const*/ char *Name);
-LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
-                          /*const*/ char *Name);
-LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
-                          /*const*/ char *Name);
-LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, /*const*/ char *Name);
-LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, /*const*/ char *Name);
-
-/* Memory */
-LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, /*const*/ char *Name);
-LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
-                                  LLVMValueRef Val, /*const*/ char *Name);
-LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, /*const*/ char *Name);
-LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty,
-                                  LLVMValueRef Val, /*const*/ char *Name);
-LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal);
-LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal,
-                           /*const*/ char *Name);
-LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr);
-LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
-                          LLVMValueRef *Indices, uint NumIndices,
-                          /*const*/ char *Name);
-LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
-                                  LLVMValueRef *Indices, uint NumIndices,
-                                  /*const*/ char *Name);
-
-/* Casts */
-LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
-                            LLVMTypeRef DestTy, /*const*/ char *Name);
-LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
-                           LLVMTypeRef DestTy, /*const*/ char *Name);
-LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
-                           LLVMTypeRef DestTy, /*const*/ char *Name);
-LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,
-                             LLVMTypeRef DestTy, /*const*/ char *Name);
-LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val,
-                             LLVMTypeRef DestTy, /*const*/ char *Name);
-LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val,
-                             LLVMTypeRef DestTy, /*const*/ char *Name);
-LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val,
-                             LLVMTypeRef DestTy, /*const*/ char *Name);
-LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val,
-                              LLVMTypeRef DestTy, /*const*/ char *Name);
-LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val,
-                            LLVMTypeRef DestTy, /*const*/ char *Name);
-LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val,
-                               LLVMTypeRef DestTy, /*const*/ char *Name);
-LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val,
-                               LLVMTypeRef DestTy, /*const*/ char *Name);
-LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val,
-                              LLVMTypeRef DestTy, /*const*/ char *Name);
-
-/* Comparisons */
-LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op,
-                           LLVMValueRef LHS, LLVMValueRef RHS,
-                           /*const*/ char *Name);
-LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op,
-                           LLVMValueRef LHS, LLVMValueRef RHS,
-                           /*const*/ char *Name);
-
-/* Miscellaneous instructions */
-LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, /*const*/ char *Name);
-LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn,
-                           LLVMValueRef *Args, uint NumArgs,
-                           /*const*/ char *Name);
-LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If,
-                             LLVMValueRef Then, LLVMValueRef Else,
-                             /*const*/ char *Name);
-LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty,
-                            /*const*/ char *Name);
-LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal,
-                                     LLVMValueRef Index, /*const*/ char *Name);
-LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal,
-                                    LLVMValueRef EltVal, LLVMValueRef Index,
-                                    /*const*/ char *Name);
-LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1,
-                                    LLVMValueRef V2, LLVMValueRef Mask,
-                                    /*const*/ char *Name);
-LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal,
-                                   uint Index, /*const*/ char *Name);
-LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal,
-                                  LLVMValueRef EltVal, uint Index,
-                                  /*const*/ char *Name);
-
-
-/*===-- Module providers --------------------------------------------------===*/
-
-/* Encapsulates the module M in a module provider, taking ownership of the
- * module.
- * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
- */
-LLVMModuleProviderRef
-LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
-
-/* Destroys the module provider MP as well as the contained module.
- * See the destructor llvm::ModuleProvider::~ModuleProvider.
- */
-void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP);
-
-
-/*===-- Memory buffers ----------------------------------------------------===*/
-
-int LLVMCreateMemoryBufferWithContentsOfFile(/*const*/ char *Path,
-                                             LLVMMemoryBufferRef *OutMemBuf,
-                                             char **OutMessage);
-int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
-                                    char **OutMessage);
-void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf);
-
-/*===-- 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. */
-LLVMPassManagerRef 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. */
-LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
-
-/** 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&). */
-int LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
-
-/** 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. */
-int LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
-
-/** 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&). */
-int LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
-
-/** 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. */
-int LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
-
-/** Frees the memory of a pass pipeline. For function pipelines, does not free
-    the module provider.
-    See llvm::PassManagerBase::~PassManagerBase. */
-void LLVMDisposePassManager(LLVMPassManagerRef PM);
--- a/tools/binding/llvm/c/ExecutionEngine.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,94 +0,0 @@
-// Converted to the D programming language by Tomas Lindquist Olsen 2008
-// Original file header:
-/*===-- llvm-c/ExecutionEngine.h - ExecutionEngine Lib C Iface --*- C++ -*-===*\
-|*                                                                            *|
-|*                     The LLVM Compiler Infrastructure                       *|
-|*                                                                            *|
-|* This file is distributed under the University of Illinois Open Source      *|
-|* License. See LICENSE.TXT for details.                                      *|
-|*                                                                            *|
-|*===----------------------------------------------------------------------===*|
-|*                                                                            *|
-|* This header declares the C interface to libLLVMExecutionEngine.o, which    *|
-|* implements various analyses of the LLVM IR.                                *|
-|*                                                                            *|
-|* Many exotic languages can interoperate with C code but have a harder time  *|
-|* with C++ due to name mangling. So in addition to C, this interface enables *|
-|* tools written in such languages.                                           *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
-
-module llvm.c.ExecutionEngine;
-
-import llvm.c.Core;
-
-extern(C):
-
-private
-{
-    struct LLVM_OpaqueGenericValue {}
-    struct LLVM_OpaqueExecutionEngine {}
-}
-
-typedef LLVM_OpaqueGenericValue* LLVMGenericValueRef;
-typedef LLVM_OpaqueExecutionEngine* LLVMExecutionEngineRef;
-
-/*===-- Operations on generic values --------------------------------------===*/
-
-LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
-                                                ulong N,
-                                                int IsSigned);
-
-LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P);
-
-LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef Ty, double N);
-
-uint LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef);
-
-ulong LLVMGenericValueToInt(LLVMGenericValueRef GenVal,
-                                         int IsSigned);
-
-void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal);
-
-double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal);
-
-void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal);
-
-/*===-- Operations on execution engines -----------------------------------===*/
-
-int LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
-                              LLVMModuleProviderRef MP,
-                              char **OutError);
-
-int LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
-                          LLVMModuleProviderRef MP,
-                          char **OutError);
-
-int LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
-                          LLVMModuleProviderRef MP,
-                          char **OutError);
-
-void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE);
-
-void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE);
-
-void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE);
-
-int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
-                          uint ArgC, /*const*/ char * /*const*/ *ArgV,
-                          /*const*/ char * /*const*/ *EnvP);
-
-LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
-                                    uint NumArgs,
-                                    LLVMGenericValueRef *Args);
-
-void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F);
-
-void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP);
-
-int LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
-                             LLVMModuleProviderRef MP,
-                             LLVMModuleRef *OutMod, char **OutError);
-
-int LLVMFindFunction(LLVMExecutionEngineRef EE, /*const*/ char *Name,
-                     LLVMValueRef *OutFn);
--- a/tools/binding/llvm/c/Ext.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,62 +0,0 @@
-// Written in the D programming language by Tomas Lindquist Olsen 2008
-// Extensions to the LLVM C interface for the D binding.
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-module llvm.c.Ext;
-
-import llvm.c.Core;
-
-// taken from llvm/Value.h
-/// An enumeration for keeping track of the concrete subclass of Value that
-/// is actually instantiated. Values of this enumeration are kept in the
-/// Value classes SubclassID field. They are used for concrete type
-/// identification.
-enum LLVMValueKind : uint
-{
-    Argument,              /// This is an instance of Argument
-    BasicBlock,            /// This is an instance of BasicBlock
-    Function,              /// This is an instance of Function
-    GlobalAlias,           /// This is an instance of GlobalAlias
-    GlobalVariable,        /// This is an instance of GlobalVariable
-    UndefValue,            /// This is an instance of UndefValue
-    ConstantExpr,          /// This is an instance of ConstantExpr
-    ConstantAggregateZero, /// This is an instance of ConstantAggregateNull
-    ConstantInt,           /// This is an instance of ConstantInt
-    ConstantFP,            /// This is an instance of ConstantFP
-    ConstantArray,         /// This is an instance of ConstantArray
-    ConstantStruct,        /// This is an instance of ConstantStruct
-    ConstantVector,        /// This is an instance of ConstantVector
-    ConstantPointerNull,   /// This is an instance of ConstantPointerNull
-    InlineAsm,             /// This is an instance of InlineAsm
-    Instruction            /// This is an instance of Instruction
-}
-
-extern(C)
-{
-    void LLVMEraseFromParent(LLVMValueRef I);
-    int LLVMIsTerminated(LLVMBasicBlockRef BB);
-    int LLVMHasPredecessors(LLVMBasicBlockRef BB);
-    int LLVMIsBasicBlockEmpty(LLVMBasicBlockRef BB);
-    void LLVMReplaceAllUsesWith(LLVMValueRef V, LLVMValueRef W);
-
-    void LLVMOptimizeModule(LLVMModuleRef M, int doinline);
-    void LLVMDumpType(LLVMTypeRef T);
-
-    LLVMValueRef LLVMGetOrInsertFunction(LLVMModuleRef M, char* Name, LLVMTypeRef Type);
-
-    /// Return a strdup()ed string which must be free()ed
-    char* LLVMValueToString(LLVMValueRef v);
-    char* LLVMTypeToString(LLVMTypeRef ty); /// ditto
-
-    LLVMValueKind LLVMGetValueKind(LLVMValueRef Value);
-
-    LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, char* Name);
-    int LLVMIsTypeAbstract(LLVMTypeRef T);
-
-    alias void function(void* handle, LLVMTypeRef newT) RefineCallback;
-    void LLVMRegisterAbstractTypeCallback(LLVMTypeRef T,
-                                          void* handle,
-                                          RefineCallback callback);
-}
--- a/tools/binding/llvm/c/Target.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,110 +0,0 @@
-// Converted to the D programming language by Tomas Lindquist Olsen 2008
-// Original file header:
-/*===-- llvm-c/Target.h - Target Lib C Iface --------------------*- C++ -*-===*\
-|*                                                                            *|
-|*                     The LLVM Compiler Infrastructure                       *|
-|*                                                                            *|
-|* This file is distributed under the University of Illinois Open Source      *|
-|* License. See LICENSE.TXT for details.                                      *|
-|*                                                                            *|
-|*===----------------------------------------------------------------------===*|
-|*                                                                            *|
-|* This header declares the C interface to libLLVMTarget.a, which             *|
-|* implements target information.                                             *|
-|*                                                                            *|
-|* Many exotic languages can interoperate with C code but have a harder time  *|
-|* with C++ due to name mangling. So in addition to C, this interface enables *|
-|* tools written in such languages.                                           *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
-
-module llvm.c.Target;
-
-import llvm.c.Core;
-
-extern(C):
-
-enum { LLVMBigEndian, LLVMLittleEndian };
-alias int LLVMByteOrdering;
-
-typedef void* LLVMTargetDataRef;
-typedef void* LLVMStructLayoutRef;
-
-
-/*===-- Target Data -------------------------------------------------------===*/
-
-/** Creates target data from a target layout string.
-    See the constructor llvm::TargetData::TargetData. */
-LLVMTargetDataRef LLVMCreateTargetData( /*const*/ char *StringRep);
-
-/** Adds target data information to a pass manager. This does not take ownership
-    of the target data.
-    See the method llvm::PassManagerBase::add. */
-void LLVMAddTargetData(LLVMTargetDataRef, LLVMPassManagerRef);
-
-/** Converts target data to a target layout string. The string must be disposed
-    with LLVMDisposeMessage.
-    See the constructor llvm::TargetData::TargetData. */
-char *LLVMCopyStringRepOfTargetData(LLVMTargetDataRef);
-
-/** Returns the byte order of a target, either LLVMBigEndian or
-    LLVMLittleEndian.
-    See the method llvm::TargetData::isLittleEndian. */
-LLVMByteOrdering LLVMByteOrder(LLVMTargetDataRef);
-
-/** Returns the pointer size in bytes for a target.
-    See the method llvm::TargetData::getPointerSize. */
-uint LLVMPointerSize(LLVMTargetDataRef);
-
-/** Returns the integer type that is the same size as a pointer on a target.
-    See the method llvm::TargetData::getIntPtrType. */
-LLVMTypeRef LLVMIntPtrType(LLVMTargetDataRef);
-
-/** Computes the size of a type in bytes for a target.
-    See the method llvm::TargetData::getTypeSizeInBits. */
-ulong LLVMSizeOfTypeInBits(LLVMTargetDataRef, LLVMTypeRef);
-
-/** Computes the storage size of a type in bytes for a target.
-    See the method llvm::TargetData::getTypeStoreSize. */
-ulong LLVMStoreSizeOfType(LLVMTargetDataRef, LLVMTypeRef);
-
-/** Computes the ABI size of a type in bytes for a target.
-    See the method llvm::TargetData::getABITypeSize. */
-ulong LLVMABISizeOfType(LLVMTargetDataRef, LLVMTypeRef);
-
-/** Computes the ABI alignment of a type in bytes for a target.
-    See the method llvm::TargetData::getTypeABISize. */
-uint LLVMABIAlignmentOfType(LLVMTargetDataRef, LLVMTypeRef);
-
-/** Computes the call frame alignment of a type in bytes for a target.
-    See the method llvm::TargetData::getTypeABISize. */
-uint LLVMCallFrameAlignmentOfType(LLVMTargetDataRef, LLVMTypeRef);
-
-/** Computes the preferred alignment of a type in bytes for a target.
-    See the method llvm::TargetData::getTypeABISize. */
-uint LLVMPreferredAlignmentOfType(LLVMTargetDataRef, LLVMTypeRef);
-
-/** Computes the preferred alignment of a global variable in bytes for a target.
-    See the method llvm::TargetData::getPreferredAlignment. */
-uint LLVMPreferredAlignmentOfGlobal(LLVMTargetDataRef,
-                                        LLVMValueRef GlobalVar);
-
-/** Computes the structure element that contains the byte offset for a target.
-    See the method llvm::StructLayout::getElementContainingOffset. */
-uint LLVMElementAtOffset(LLVMTargetDataRef, LLVMTypeRef StructTy,
-                             ulong Offset);
-
-/** Computes the byte offset of the indexed struct element for a target.
-    See the method llvm::StructLayout::getElementContainingOffset. */
-ulong LLVMOffsetOfElement(LLVMTargetDataRef, LLVMTypeRef StructTy,
-                                       uint Element);
-
-/** 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. */
-void LLVMInvalidateStructLayout(LLVMTargetDataRef, LLVMTypeRef StructTy);
-
-/** Deallocates a TargetData.
-    See the destructor llvm::TargetData::~TargetData. */
-void LLVMDisposeTargetData(LLVMTargetDataRef);
--- a/tools/binding/llvm/c/transforms/IPO.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,62 +0,0 @@
-// Converted to the D programming language by Tomas Lindquist Olsen 2009
-
-/*===-- IPO.h - Interprocedural Transformations C Interface -----*- C++ -*-===*\
-|*                                                                            *|
-|*                     The LLVM Compiler Infrastructure                       *|
-|*                                                                            *|
-|* This file is distributed under the University of Illinois Open Source      *|
-|* License. See LICENSE.TXT for details.                                      *|
-|*                                                                            *|
-|*===----------------------------------------------------------------------===*|
-|*                                                                            *|
-|* This header declares the C interface to libLLVMIPO.a, which implements     *|
-|* various interprocedural transformations of the LLVM IR.                    *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
-module llvm.c.transforms.IPO;
-
-import llvm.c.Core;
-
-extern(C):
-
-/** See llvm::createArgumentPromotionPass function. */
-void LLVMAddArgumentPromotionPass(LLVMPassManagerRef PM);
-
-/** See llvm::createConstantMergePass function. */
-void LLVMAddConstantMergePass(LLVMPassManagerRef PM);
-
-/** See llvm::createDeadArgEliminationPass function. */
-void LLVMAddDeadArgEliminationPass(LLVMPassManagerRef PM);
-
-/** See llvm::createDeadTypeEliminationPass function. */
-void LLVMAddDeadTypeEliminationPass(LLVMPassManagerRef PM);
-
-/** See llvm::createFunctionAttrsPass function. */
-void LLVMAddFunctionAttrsPass(LLVMPassManagerRef PM);
-
-/** See llvm::createFunctionInliningPass function. */
-void LLVMAddFunctionInliningPass(LLVMPassManagerRef PM);
-
-/** See llvm::createGlobalDCEPass function. */
-void LLVMAddGlobalDCEPass(LLVMPassManagerRef PM);
-
-/** See llvm::createGlobalOptimizerPass function. */
-void LLVMAddGlobalOptimizerPass(LLVMPassManagerRef PM);
-
-/** See llvm::createIPConstantPropagationPass function. */
-void LLVMAddIPConstantPropagationPass(LLVMPassManagerRef PM);
-
-/** See llvm::createLowerSetJmpPass function. */
-void LLVMAddLowerSetJmpPass(LLVMPassManagerRef PM);
-
-/** See llvm::createPruneEHPass function. */
-void LLVMAddPruneEHPass(LLVMPassManagerRef PM);
-
-/** See llvm::createRaiseAllocationsPass function. */
-void LLVMAddRaiseAllocationsPass(LLVMPassManagerRef PM);
-
-/** See llvm::createStripDeadPrototypesPass function. */
-void LLVMAddStripDeadPrototypesPass(LLVMPassManagerRef PM);
-
-/** See llvm::createStripSymbolsPass function. */
-void LLVMAddStripSymbolsPass(LLVMPassManagerRef PM);
--- a/tools/binding/llvm/c/transforms/Scalar.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,93 +0,0 @@
-// Converted to the D programming language by Tomas Lindquist Olsen 2009
-
-/*===-- Scalar.h - Scalar Transformation Library C Interface ----*- C++ -*-===*\
-|*                                                                            *|
-|*                     The LLVM Compiler Infrastructure                       *|
-|*                                                                            *|
-|* This file is distributed under the University of Illinois Open Source      *|
-|* License. See LICENSE.TXT for details.                                      *|
-|*                                                                            *|
-|*===----------------------------------------------------------------------===*|
-|*                                                                            *|
-|* This header declares the C interface to libLLVMScalarOpts.a, which         *|
-|* implements various scalar transformations of the LLVM IR.                  *|
-|*                                                                            *|
-|* Many exotic languages can interoperate with C code but have a harder time  *|
-|* with C++ due to name mangling. So in addition to C, this interface enables *|
-|* tools written in such languages.                                           *|
-|*                                                                            *|
-\*===----------------------------------------------------------------------===*/
-module llvm.c.transforms.Scalar;
-
-import llvm.c.Core;
-
-extern(C):
-
-/** See llvm::createAggressiveDCEPass function. */
-void LLVMAddAggressiveDCEPass(LLVMPassManagerRef PM);
-
-/** See llvm::createCFGSimplificationPass function. */
-void LLVMAddCFGSimplificationPass(LLVMPassManagerRef PM);
-
-/** See llvm::createCondPropagationPass function. */
-void LLVMAddCondPropagationPass(LLVMPassManagerRef PM);
-
-/** See llvm::createDeadStoreEliminationPass function. */
-void LLVMAddDeadStoreEliminationPass(LLVMPassManagerRef PM);
-
-/** See llvm::createGVNPass function. */
-void LLVMAddGVNPass(LLVMPassManagerRef PM);
-
-/** See llvm::createIndVarSimplifyPass function. */
-void LLVMAddIndVarSimplifyPass(LLVMPassManagerRef PM);
-
-/** See llvm::createInstructionCombiningPass function. */
-void LLVMAddInstructionCombiningPass(LLVMPassManagerRef PM);
-
-/** See llvm::createJumpThreadingPass function. */
-void LLVMAddJumpThreadingPass(LLVMPassManagerRef PM);
-
-/** See llvm::createLICMPass function. */
-void LLVMAddLICMPass(LLVMPassManagerRef PM);
-
-/** See llvm::createLoopDeletionPass function. */
-void LLVMAddLoopDeletionPass(LLVMPassManagerRef PM);
-
-/** See llvm::createLoopIndexSplitPass function. */
-void LLVMAddLoopIndexSplitPass(LLVMPassManagerRef PM);
-
-/** See llvm::createLoopRotatePass function. */
-void LLVMAddLoopRotatePass(LLVMPassManagerRef PM);
-
-/** See llvm::createLoopUnrollPass function. */
-void LLVMAddLoopUnrollPass(LLVMPassManagerRef PM);
-
-/** See llvm::createLoopUnswitchPass function. */
-void LLVMAddLoopUnswitchPass(LLVMPassManagerRef PM);
-
-/** See llvm::createMemCpyOptPass function. */
-void LLVMAddMemCpyOptPass(LLVMPassManagerRef PM);
-
-/** See llvm::createPromoteMemoryToRegisterPass function. */
-void LLVMAddPromoteMemoryToRegisterPass(LLVMPassManagerRef PM);
-
-/** See llvm::createReassociatePass function. */
-void LLVMAddReassociatePass(LLVMPassManagerRef PM);
-
-/** See llvm::createSCCPPass function. */
-void LLVMAddSCCPPass(LLVMPassManagerRef PM);
-
-/** See llvm::createScalarReplAggregatesPass function. */
-void LLVMAddScalarReplAggregatesPass(LLVMPassManagerRef PM);
-
-/** See llvm::createSimplifyLibCallsPass function. */
-void LLVMAddSimplifyLibCallsPass(LLVMPassManagerRef PM);
-
-/** See llvm::createTailCallEliminationPass function. */
-void LLVMAddTailCallEliminationPass(LLVMPassManagerRef PM);
-
-/** See llvm::createConstantPropagationPass function. */
-void LLVMAddConstantPropagationPass(LLVMPassManagerRef PM);
-
-/** See llvm::demotePromoteMemoryToRegisterPass function. */
-void LLVMAddDemoteMemoryToRegisterPass(LLVMPassManagerRef PM);
--- a/tools/binding/llvm/executionengine.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,224 +0,0 @@
-// Written in the D programming language by Frits van Bommel 2008
-// Binding of llvm.c.ExecutionEngine for D.
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-module llvm.executionengine;
-
-import llvm.c.Core;
-import llvm.c.ExecutionEngine;
-
-import llvm.llvm;
-import llvm.util;
-
-///
-class GenericValue
-{
-    ///
-    private LLVMGenericValueRef value;
-    ///
-    private this(LLVMGenericValueRef v)
-    {
-        value = v;
-    }
-    ///
-    void dispose()
-    {
-        LLVMDisposeGenericValue(value);
-        value = null;
-    }
-    ///
-    ~this()
-    {
-        dispose();  // safe because value isn't on the GC heap and isn't exposed.
-    }
-    ///
-    static GenericValue GetS(IntegerType ty, long N)
-    {
-        return new GenericValue(LLVMCreateGenericValueOfInt(ty.ll, N, true));
-    }
-    ///
-    static GenericValue GetU(IntegerType ty, ulong N)
-    {
-        return new GenericValue(LLVMCreateGenericValueOfInt(ty.ll, N, false));
-    }
-    ///
-    static GenericValue GetP(void* P)
-    {
-        return new GenericValue(LLVMCreateGenericValueOfPointer(P));
-    }
-    ///
-    static GenericValue GetF(RealType ty, double N)
-    {
-        return new GenericValue(LLVMCreateGenericValueOfFloat(ty.ll, N));
-    }
-    ///
-    uint intWidth()
-    {
-        return LLVMGenericValueIntWidth(value);
-    }
-    ///
-    ulong toUInt()
-    {
-        return LLVMGenericValueToInt(value, false);
-    }
-    ///
-    long toSInt()
-    {
-        return LLVMGenericValueToInt(value, true);
-    }
-    ///
-    void* toPointer()
-    {
-        return LLVMGenericValueToPointer(value);
-    }
-    ///
-    double toFloat(RealType ty)
-    {
-        return LLVMGenericValueToFloat(ty.ll, value);
-    }
-}
-
-
-///
-class ExecutionEngine
-{
-    ///
-    private LLVMExecutionEngineRef ee;
-    ///
-    private this(LLVMExecutionEngineRef ee)
-    {
-        this.ee = ee;
-    }
-    ///
-    static ExecutionEngine Create(ModuleProvider mp)
-    {
-        LLVMExecutionEngineRef ee;
-        char* err;
-        if (LLVMCreateExecutionEngine(&ee, mp.ll, &err))
-        {
-            auto errmsg = from_stringz(err).dup;
-            LLVMDisposeMessage(err);
-            if (errmsg.length == 0)
-                errmsg = "Error creating execution engine";
-            throw new LLVMException(errmsg);
-        }
-        return new ExecutionEngine(ee);
-    }
-    ///
-    static ExecutionEngine CreateInterpreter(ModuleProvider mp)
-    {
-        LLVMExecutionEngineRef ee;
-        char* err;
-        if (LLVMCreateInterpreter(&ee, mp.ll, &err))
-        {
-            auto errmsg = from_stringz(err).dup;
-            LLVMDisposeMessage(err);
-            if (errmsg.length == 0)
-                errmsg = "Error creating interpreter";
-            throw new LLVMException(errmsg);
-        }
-        return new ExecutionEngine(ee);
-    }
-    ///
-    static ExecutionEngine CreateJIT(ModuleProvider mp)
-    {
-        LLVMExecutionEngineRef ee;
-        char* err;
-        if (LLVMCreateJITCompiler(&ee, mp.ll, &err))
-        {
-            auto errmsg = from_stringz(err).dup;
-            LLVMDisposeMessage(err);
-            if (errmsg.length == 0)
-                errmsg = "Error creating JIT";
-            throw new LLVMException(errmsg);
-        }
-        return new ExecutionEngine(ee);
-    }
-    ///
-    void dispose()
-    {
-        LLVMDisposeExecutionEngine(ee);
-        ee = null;
-    }
-    ///
-    ~this()
-    {
-        dispose(); // safe because ee isn't on the GC heap and isn't exposed.
-    }
-    ///
-    void runStaticConstructors()
-    {
-        LLVMRunStaticConstructors(ee);
-    }
-    ///
-    void runStaticDestructors()
-    {
-        LLVMRunStaticDestructors(ee);
-    }
-    ///
-    int runAsMain(Function f, char[][] args = null, char[][] env = null) {
-        auto argv = new char*[args.length];
-        foreach (size_t idx, ref arg; args)
-        {
-            argv[idx] = to_stringz(arg);
-        }
-
-        auto envp = new char*[env.length + 1];
-        foreach (size_t idx, ref envvar ; env)
-        {
-            envp[idx] = to_stringz(envvar);
-        }
-        envp[$-1] = null;
-
-        return LLVMRunFunctionAsMain(ee, f.value, argv.length, argv.ptr, envp.ptr);
-    }
-    ///
-    GenericValue run(Function f, GenericValue[] args = null)
-    {
-        auto cargs = new LLVMGenericValueRef[args.length];
-        foreach (size_t idx, ref arg ; args)
-        {
-            cargs[idx] = arg.value;
-        }
-
-        auto result = LLVMRunFunction(ee, f.value, cargs.length, cargs.ptr);
-        return new GenericValue(result);
-    }
-    ///
-    void freeMachineCodeForFunction(Function f)
-    {
-        LLVMFreeMachineCodeForFunction(ee, f.value);
-    }
-    ///
-    void addModuleProvider(ModuleProvider mp)
-    {
-        LLVMAddModuleProvider(ee, mp.ll);
-    }
-    ///
-    Module removeModuleProvider(ModuleProvider mp)
-    {
-        LLVMModuleRef mod;
-        char* err;
-        if (LLVMRemoveModuleProvider(ee, mp.ll, &mod, &err))
-        {
-            auto errmsg = from_stringz(err).dup;
-            LLVMDisposeMessage(err);
-            if (errmsg.length == 0)
-                errmsg = "Error removing ModuleProvider from ExecutionEngine";
-            throw new LLVMException(errmsg);
-        }
-        return Module.GetExisting(mod);
-    }
-    ///
-    Function findFunction(char[] name)
-    {
-        LLVMValueRef fn;
-        if (LLVMFindFunction(ee, to_stringz(name), &fn))
-        {
-            return null;
-        }
-        return new Function(fn, getTypeOf(fn));
-    }
-}
--- a/tools/binding/llvm/llvm.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1033 +0,0 @@
-// Written in the D programming language by Tomas Lindquist Olsen 2008
-// Binding of llvm.c.Core values for D.
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-module llvm.llvm;
-
-import llvm.c.Core;
-import llvm.c.Ext;
-import llvm.c.BitWriter;
-import llvm.c.BitReader;
-import llvm.c.Analysis;
-import llvm.c.Target;
-
-public import llvm.type;
-public import llvm.builder;
-
-import llvm.util;
-
-///
-class LLVMException : Exception
-{
-    this(char[] msg) {
-        super(msg);
-    }
-}
-
-version(Tango) {
-    import tango.stdc.stdlib;
-}
-else {
-    import std.c.stdlib;
-}
-///
-alias LLVMLinkage Linkage;
-///
-alias LLVMIntPredicate IntPredicate;
-///
-alias LLVMRealPredicate RealPredicate;
-///
-alias LLVMCallConv CallConv;
-///
-alias LLVMVisibility Visibility;
-///
-alias LLVMValueKind ValueKind;
-
-///
-class Module
-{
-    /// global registry for 1:1 mapping of ModuleRef's -> Module's
-    private static Module[LLVMModuleRef] registry;
-    ///
-    private LLVMModuleRef mod;
-    const char[] name;
-    
-    // Make all methods final to enable linking with just needed libs.
-    // To make use of this if compiling with GDC: use -ffunction-sections when
-    // compiling and --gc-sections when linking.
-    // (Final avoids references in the vtable)
-    final:
-    
-    ///
-    this(char[] nam)
-    {
-        name = nam;
-        mod = LLVMModuleCreateWithName(to_stringz(nam));
-        registry[mod] = this;
-    }
-    ///
-    private this(LLVMModuleRef m)
-    {
-        name = null;
-        mod = m;
-        registry[m] = this;
-    }
-    ///
-    static package Module GetExisting(LLVMModuleRef m)
-    {
-        if (auto p = m in registry)
-        {
-            return *p;
-        }
-        return new Module(m);
-    }
-    /// Create a module from bitcode. Returns the Module on success, null on failure.
-    static Module GetFromBitcode(char[] bitcodepath, ref char[] errmsg)
-    {
-        LLVMModuleRef mref;
-        LLVMMemoryBufferRef bref;
-        char* msg;
-        if (LLVMCreateMemoryBufferWithContentsOfFile(to_stringz(bitcodepath), &bref, &msg))
-        {
-            errmsg = from_stringz(msg).dup;
-            LLVMDisposeMessage(msg);
-            if (errmsg.length == 0)
-                errmsg = "Error reading bitcode file";
-            throw new LLVMException(errmsg);
-        }
-        scope(exit)
-            LLVMDisposeMemoryBuffer(bref);
-        
-        if (LLVMParseBitcode(bref, &mref, &msg))
-        {
-            errmsg = from_stringz(msg).dup;
-            LLVMDisposeMessage(msg);
-            if (errmsg.length == 0)
-                errmsg = "Error parsing bitcode";
-            LLVMDisposeMemoryBuffer(bref);
-            throw new LLVMException(errmsg);
-        }
-        return new Module(mref);
-    }
-    /// important to call this when done
-    void dispose()
-    {
-        if (mod)
-        {
-            registry.remove(mod);
-            LLVMDisposeModule(mod);
-            mod = null;
-        }
-    }
-    ///
-    char[] dataLayout()
-    {
-        assert(mod !is null);
-        return from_stringz(LLVMGetDataLayout(mod));
-    }
-    ///
-    void dataLayout(char[] dl)
-    {
-        assert(mod !is null);
-        LLVMSetDataLayout(mod, to_stringz(dl));
-    }
-    ///
-    char[] target()
-    {
-        assert(mod !is null);
-        return from_stringz(LLVMGetTarget(mod));
-    }
-    ///
-    void target(char[] dl)
-    {
-        assert(mod !is null);
-        LLVMSetTarget(mod, to_stringz(dl));
-    }
-    ///
-    bool addTypeName(char[] nam, Type t)
-    {
-        assert(mod !is null);
-        return LLVMAddTypeName(mod, to_stringz(nam), t.ll) != 0;
-    }
-    ///
-    Type getTypeByName(char[] name) {
-        return getTypeOf(LLVMGetTypeByName(mod, to_stringz(name)));
-    }
-    ///
-    void deleteTypeName(char[] nam)
-    {
-        assert(mod !is null);
-        LLVMDeleteTypeName(mod, to_stringz(nam));
-    }
-    ///
-    GlobalVariable addGlobal(Type t, char[] nam)
-    {
-        assert(mod !is null);
-        auto c = LLVMAddGlobal(mod, t.ll, to_stringz(nam));
-        assert(c !is null);
-        return new GlobalVariable(c, getTypeOf(c));
-    }
-    /// Convenience method, type is taken to be that of the initializer
-    GlobalVariable addGlobal(Constant initializer, char[] name)
-    {
-        auto global = addGlobal(initializer.type, name);
-        global.initializer = initializer;
-        return global;
-    }
-    ///
-    GlobalValue getNamedGlobal(char[] nam)
-    {
-        assert(mod !is null);
-        auto c = LLVMGetNamedGlobal(mod, to_stringz(nam));
-        if (c is null) return null;
-        return cast(GlobalValue)getValueOf(c);
-    }
-    ///
-    Function addFunction(Type t, char[] nam)
-    {
-        assert(mod !is null);
-        auto c = LLVMAddFunction(mod, to_stringz(nam), t.ll);
-        assert(c !is null);
-        return new Function(c, getTypeOf(c));
-    }
-    ///
-    Function getNamedFunction(char[] nam)
-    {
-        assert(mod !is null);
-        auto c = LLVMGetNamedFunction(mod, to_stringz(nam));
-        if (c is null) return null;
-        return cast(Function)getValueOf(c);
-    }
-    ///
-    Function getOrInsertFunction(Type t, char[] nam)
-    {
-        assert(mod !is null);
-        auto c = LLVMGetOrInsertFunction(mod, to_stringz(nam), t.ll);
-        auto val = getValueOf(c);
-        auto fn = cast(Function) val;
-        // Can happen if 'nam' names a function of a different type:
-        assert(fn !is null, "Not a function of type " ~ t.toString() ~ ": " ~ val.toString());
-        return fn;
-    }
-    /// Performs the same optimizations as `opt -std-compile-opts ...' would on the module.
-    /// If inline is true, function inlining will be performed.
-    void optimize(bool inline)
-    {
-        LLVMOptimizeModule(mod, inline);
-    }
-    /// Writes the module to an open file descriptor. Returns true on success.
-    bool writeBitcodeToFileHandle(int handle)
-    {
-        return (LLVMWriteBitcodeToFileHandle(mod, handle) == 0);
-    }
-    /// Writes the module to the specified path. Returns 0 on success.
-    bool writeBitcodeToFile(char[] path)
-    {
-        return (LLVMWriteBitcodeToFile(mod, to_stringz(path)) == 0);
-    }
-    /// Throws an exception if the module doesn't pass the LLVM verifier.
-    void verify()
-    {
-        char* msg;
-        if (LLVMVerifyModule(mod, LLVMVerifierFailureAction.ReturnStatus, &msg))
-        {
-            auto errmsg = from_stringz(msg).dup;
-            LLVMDisposeMessage(msg);
-            if (errmsg.length == 0)
-                errmsg = "Module verification failed";
-            throw new LLVMException(errmsg);
-        }
-    }
-}
-
-class ModuleProvider
-{
-    ///
-    private LLVMModuleProviderRef mp;
-    ///
-    private this(LLVMModuleProviderRef mp)
-    {
-        this.mp = mp;
-    }
-    /// Takes ownership of module, returns a ModuleProvider for it.
-    static ModuleProvider GetForModule(Module m)
-    {
-        auto mp = LLVMCreateModuleProviderForExistingModule(m.mod);
-        return new ModuleProvider(mp);
-    }
-    /// Destroys the provided module, unless this MP was passed to an ExecutionEngine.
-    void dispose()
-    {
-        LLVMDisposeModuleProvider(mp);
-        mp = null;
-    }
-    /// Returns a lazily-deserializing ModuleProvider
-    static ModuleProvider GetFromBitcode(char[] filename)
-    {
-        LLVMMemoryBufferRef buf;
-        char* msg;
-        if (LLVMCreateMemoryBufferWithContentsOfFile(to_stringz(filename), &buf, &msg))
-        {
-            auto errmsg = from_stringz(msg).dup;
-            LLVMDisposeMessage(msg);
-            if (errmsg.length == 0)
-                errmsg = "ModuleProvider: Error reading bitcode file";
-            throw new LLVMException(errmsg);
-        }
-        
-        LLVMModuleProviderRef mp;
-        // Takes ownership of buffer ...
-        if (LLVMGetBitcodeModuleProvider(buf, &mp, &msg))
-        {
-            // ... unless it fails, in which case we need to clean it up ourselves
-            LLVMDisposeMemoryBuffer(buf);
-            
-            auto errmsg = from_stringz(msg).dup;
-            LLVMDisposeMessage(msg);
-            if (errmsg.length == 0)
-                errmsg = "Error creating ModuleProvider for bitcode file";
-            throw new LLVMException(errmsg);
-        }
-        return new ModuleProvider(mp);
-    }
-    ///
-    package LLVMModuleProviderRef ll()
-    {
-        return mp;
-    }
-}
-
-///
-class Value
-{
-    ///
-    const LLVMValueRef value;
-    ///
-    const Type type;
-    ///
-    this(LLVMValueRef v, Type t=null) {
-        value = v;
-        if (t is null) t = getTypeOf(v);
-        type = t;
-    }
-    ///
-    char[] toString() {
-        auto cstr = LLVMValueToString(value);
-        auto result = from_stringz(cstr).dup;
-        free(cstr);
-        return result;
-    }
-    ///
-    ValueKind kind()
-    {
-        return LLVMGetValueKind(value);
-    }
-    ///
-    char[] name()
-    {
-        return from_stringz(LLVMGetValueName(value));
-    }
-    ///
-    void name(char[] s)
-    {
-        LLVMSetValueName(value, to_stringz(s));
-    }
-    ///
-    void dump() {
-        LLVMDumpValue(value);
-    }
-    ///
-    bool isConstant()
-    {
-        return LLVMIsConstant(value) != 0;
-    }
-    ///
-    int opEquals(Object o)
-    {
-        auto v = cast(Value)o;
-        if (v is null) return 0;
-        if (value is v.value)
-            return 1;
-        return 0;
-    }
-    /// invalidates object
-    void eraseFromParent()
-    {
-        LLVMEraseFromParent(value);
-    }
-    /// ditto
-    void replaceAllUsesWith(Value newval)
-    {
-        LLVMReplaceAllUsesWith(value, newval.value);
-    }
-
-    /// only for call's
-    void callConv(uint CC)
-    {
-        LLVMSetInstructionCallConv(value, CC);
-    }
-    /// ditto
-    uint callConv()
-    {
-        return LLVMGetInstructionCallConv(value);
-    }
-
-    /// only for phi's
-    void addIncoming(Value[] inValues, BasicBlock[] inBlocks)
-    {
-        auto n = inValues.length;
-        assert(n == inBlocks.length);
-        auto v = new LLVMValueRef[n];
-        auto b = new LLVMBasicBlockRef[n];
-        for (size_t i=0; i<n; i++) {
-            v[i] = inValues[i].value;
-            b[i] = inBlocks[i].bb;
-        }
-        LLVMAddIncoming(value, v.ptr, b.ptr, n);
-    }
-    /// ditto
-    uint numIncoming()
-    {
-        return LLVMCountIncoming(value);
-    }
-    /// ditto
-    Value getIncomingValue(uint index)
-    {
-        return getValueOf(LLVMGetIncomingValue(value, index));
-    }
-    /// ditto
-    BasicBlock getIncomingBlock(uint index)
-    {
-        // TODO bb's should be unique as well
-        return new BasicBlock(LLVMGetIncomingBlock(value, index));
-    }
-
-    /// only for switch's
-    void addCase(Value onval, BasicBlock b)
-    {
-        LLVMAddCase(value, onval.value, b.bb);
-    }
-}
-
-///
-Value getValueOf(LLVMValueRef v)
-{
-    auto kind = LLVMGetValueKind(v);
-    switch(kind)
-    {
-    case ValueKind.Argument:
-    case ValueKind.InlineAsm:
-    case ValueKind.Instruction:
-        return new Value(v);
-
-    case ValueKind.Function:
-        return new Function(v, getTypeOf(v));
-
-    case ValueKind.GlobalVariable:
-        return new GlobalVariable(v, getTypeOf(v));
-
-    case ValueKind.GlobalAlias:
-    case ValueKind.UndefValue:
-    case ValueKind.ConstantExpr:
-    case ValueKind.ConstantAggregateZero:
-    case ValueKind.ConstantPointerNull:
-        return new Constant(v, getTypeOf(v));
-
-    case ValueKind.ConstantInt:
-        return new ConstantInt(v, getTypeOf(v));
-
-    case ValueKind.ConstantFP:
-        return new ConstantReal(v, getTypeOf(v));
-
-    case ValueKind.ConstantArray:
-        return new ConstantArray(v, getTypeOf(v));
-
-    case ValueKind.ConstantStruct:
-        return new ConstantStruct(v, getTypeOf(v));
-
-    case ValueKind.ConstantVector:
-        return new ConstantVector(v, getTypeOf(v));
-
-    case ValueKind.BasicBlock:
-    default:
-        assert(0);
-    }
-}
-
-private
-{
-    template GenericConstUnaOp(char[] N)
-    {
-        const GenericConstUnaOp =
-        "Constant Get"~N~"(Constant v) {
-            auto c = LLVMConst"~N~"(v.value);
-            return cast(Constant)getValueOf(c);
-        }";
-    }
-
-    template GenericConstBinOp(char[] N)
-    {
-        const GenericConstBinOp =
-        "Constant Get"~N~"(Constant l, Constant r) {
-            auto c = LLVMConst"~N~"(l.value, r.value);
-            return cast(Constant)getValueOf(c);
-        }";
-    }
-
-    template GenericConstTriOp(char[] N)
-    {
-        const GenericConstTriOp =
-        "Constant Get"~N~"(Constant s, Constant t, Constant u) {
-            auto c = LLVMConst"~N~"(s.value, t.value, u.value);
-            return cast(Constant)getValueOf(c);
-        }";
-    }
-
-    template GenericConstCast(char[] N)
-    {
-        const GenericConstCast =
-        "Constant Get"~N~"(Constant v, Type t) {
-            auto c = LLVMConst"~N~"(v.value, t.ll);
-            return cast(Constant)getValueOf(c);
-        }";
-    }
-
-    template GenericConstCmp(char[] PRED, char[] N)
-    {
-        const GenericConstCmp =
-        "Constant Get"~N~"("~PRED~"Predicate p, Constant l, Constant r) {
-            auto c = LLVMConst"~N~"(p, l.value, r.value);
-            return cast(Constant)getValueOf(c);
-        }";
-    }
-
-    template StringDistribute(alias T, U...)
-    {
-        static if (!U.length)
-            const char[] StringDistribute="";
-        else
-            const char[] StringDistribute = T!(U[0]) ~ StringDistribute!(T, U[1..$]);
-    }
-}
-
-///
-class Constant : Value
-{
-    ///
-    protected this(LLVMValueRef v, Type t)
-    {
-        super(v,t);
-    }
-
-    ///
-    static Constant GetNull(Type t)
-    {
-        return cast(Constant)getValueOf(LLVMConstNull(t.ll));
-    }
-    /// only for int/vector
-    static Constant GetAllOnes(Type t)
-    {
-        return cast(Constant)getValueOf(LLVMConstAllOnes(t.ll));
-    }
-    ///
-    static Constant GetUndef(Type t)
-    {
-        return cast(Constant)getValueOf(LLVMGetUndef(t.ll));
-    }
-    ///
-    static ConstantInt GetTrue()
-    {
-        return ConstantInt.GetU(Type.Int1, 1);
-    }
-    ///
-    static ConstantInt GetFalse()
-    {
-        return ConstantInt.GetU(Type.Int1, 0);
-    }
-
-    ///
-    bool isNull()
-    {
-        return LLVMIsNull(value) != 0;
-    }
-    ///
-    bool isUndef()
-    {
-        return LLVMIsUndef(value) != 0;
-    }
-
-    static
-    {
-        ///
-        mixin(StringDistribute!(GenericConstUnaOp,
-            "Neg","Not"
-        ));
-        ///
-        mixin(StringDistribute!(GenericConstBinOp,
-            "Add","Sub","Mul","UDiv","SDiv","FDiv","URem","SRem","FRem",
-            "And","Or","Xor","Shl","LShr","AShr",
-            "ExtractElement"
-        ));
-        ///
-        mixin(StringDistribute!(GenericConstCast,
-            "Trunc","SExt","ZExt","FPTrunc","FPExt",
-            "UIToFP","SIToFP","FPToUI","FPToSI",
-            "PtrToInt","IntToPtr","BitCast"
-        ));
-        ///
-        mixin(StringDistribute!(GenericConstTriOp,
-            "Select",
-            "InsertElement",
-            "ShuffleVector"
-        ));
-        ///
-        mixin(GenericConstCmp!("Int","ICmp"));
-        ///
-        mixin(GenericConstCmp!("Real","FCmp"));
-        ///
-        Constant GetGEP(Constant ptr, Constant[] idxs...)
-        {
-            static if (size_t.max > uint.max) {
-                assert(idxs.length <= uint.max, "Ridiculous number of indexes to GEP");
-            }
-            auto ar = new LLVMValueRef[idxs.length];
-            foreach(i,v; idxs) ar[i] = v.value;
-            auto c = LLVMConstGEP(ptr.value, ar.ptr, ar.length);
-            return cast(Constant)getValueOf(c);
-        }
-        ///
-        Constant GetExtractValue(Constant agg, uint[] idxs...) {
-            static if (size_t.max > uint.max) {
-                assert(idxs.length <= uint.max, "Ridiculous number of indexes to ExtractValue");
-            }
-            auto c = LLVMConstExtractValue(agg.value, idxs.ptr, idxs.length);
-            return cast(Constant)getValueOf(c);
-        }
-        ///
-        Constant GetInsertValue(Constant agg, Constant elt, uint[] idxs...) {
-            static if (size_t.max > uint.max) {
-                assert(idxs.length <= uint.max, "Ridiculous number of indexes to InsertValue");
-            }
-            auto c = LLVMConstInsertValue(agg.value, elt.value, idxs.ptr, idxs.length);
-            return cast(Constant)getValueOf(c);
-        }
-        ///
-        Constant GetSizeOf(Type t)
-        {
-            return cast(Constant)getValueOf(LLVMSizeOf(t.ll));
-        }
-    }
-}
-
-///
-abstract class ScalarConstant : Constant
-{
-    ///
-    protected this(LLVMValueRef v, Type t)
-    {
-        super(v, t);
-    }
-}
-
-///
-class ConstantInt : ScalarConstant
-{
-    ///
-    private this(LLVMValueRef v, Type t)
-    {
-        super(v, t);
-    }
-    ///
-    static ConstantInt Get(Type t, ulong N, bool signExt)
-    {
-        auto c = LLVMConstInt(t.ll, N, signExt);
-        return new ConstantInt(c, t);
-    }
-    ///
-    static ConstantInt GetS(Type t, long N)
-    {
-        return Get(t, cast(ulong)N, true);
-    }
-    ///
-    static ConstantInt GetU(Type t, ulong N)
-    {
-        return Get(t, N, false);
-    }
-}
-
-///
-class ConstantReal : ScalarConstant
-{
-    ///
-    private this(LLVMValueRef v, Type t)
-    {
-        super(v, t);
-    }
-    ///
-    static ConstantReal Get(Type t, real N)
-    {
-        auto c = LLVMConstReal(t.ll, N);
-        return new ConstantReal(c, t);
-    }
-}
-
-///
-abstract class CompositeConstant : Constant
-{
-    ///
-    protected this(LLVMValueRef v, Type t)
-    {
-        super(v, t);
-    }
-}
-
-///
-class ConstantArray : CompositeConstant
-{
-    ///
-    private this(LLVMValueRef v, Type t)
-    {
-        super(v, t);
-    }
-    ///
-    static ConstantArray Get(Type eltty, Constant[] vals)
-    {
-        auto p = new LLVMValueRef[vals.length];
-        foreach(i,v; vals) p[i] = v.value;
-        auto c = LLVMConstArray(eltty.ll, p.ptr, p.length);
-        return new ConstantArray(c, getTypeOf(c));
-    }
-    ///
-    static ConstantArray GetString(char[] str, bool nullterm)
-    {
-        auto len = str.length + nullterm;
-        auto c = LLVMConstString(str.ptr, str.length, !nullterm);
-        return new ConstantArray(c, getTypeOf(c));
-    }
-}
-
-///
-class ConstantStruct : CompositeConstant
-{
-    ///
-    private this(LLVMValueRef v, Type t)
-    {
-        super(v, t);
-    }
-    ///
-    static ConstantStruct Get(Constant[] vals, bool packed=false)
-    {
-        auto p = new LLVMValueRef[vals.length];
-        foreach(i,v; vals) p[i] = v.value;
-        auto c = LLVMConstStruct(p.ptr, p.length, packed);
-        return new ConstantStruct(c, getTypeOf(c));
-    }
-}
-
-///
-class ConstantVector : CompositeConstant
-{
-    ///
-    private this(LLVMValueRef v, Type t)
-    {
-        super(v, t);
-    }
-    ///
-    static ConstantVector Get(ScalarConstant[] vals)
-    {
-        auto p = new LLVMValueRef[vals.length];
-        foreach(i,v; vals) p[i] = v.value;
-        auto c = LLVMConstVector(p.ptr, p.length);
-        return new ConstantVector(c, getTypeOf(c));
-    }
-}
-
-///
-abstract class GlobalValue : Constant
-{
-    ///
-    private this(LLVMValueRef v, Type t) {
-        super(v, t);
-    }
-    ///
-    bool isDeclaration()
-    {
-        return LLVMIsDeclaration(value) != 0;
-    }
-    ///
-    Linkage linkage()
-    {
-        return LLVMGetLinkage(value);
-    }
-    ///
-    void linkage(Linkage l)
-    {
-        LLVMSetLinkage(value, l);
-    }
-    ///
-    char[] section()
-    {
-        return from_stringz(LLVMGetSection(value));
-    }
-    ///
-    void section(char[] s)
-    {
-        LLVMSetSection(value, to_stringz(s));
-    }
-    ///
-    Visibility visibility()
-    {
-        return LLVMGetVisibility(value);
-    }
-    ///
-    void visibility(Visibility v)
-    {
-        LLVMSetVisibility(value, v);
-    }
-    ///
-    uint alignment()
-    {
-        return LLVMGetAlignment(value);
-    }
-    ///
-    void alignment(uint bytes)
-    {
-        LLVMSetAlignment(value, bytes);
-    }
-}
-
-///
-class GlobalVariable : GlobalValue
-{
-    /// TODO: void DeleteGlobal(ValueRef GlobalVar);
-
-    ///
-    private this(LLVMValueRef v, Type t) {
-        super(v, t);
-    }
-    ///
-    bool hasInitializer()
-    {
-        return isDeclaration() == 0;
-    }
-    ///
-    Constant initializer()
-    {
-        auto c = LLVMGetInitializer(value);
-        if (c is null) return null;
-        return cast(Constant)getValueOf(c);
-    }
-    ///
-    void initializer(Constant c)
-    {
-        LLVMSetInitializer(value, c.value);
-    }
-    ///
-    bool threadLocal()
-    {
-        return LLVMIsThreadLocal(value) != 0;
-    }
-    ///
-    void threadLocal(bool b)
-    {
-        LLVMSetThreadLocal(value, b);
-    }
-    ///
-    bool globalConstant()
-    {
-        return LLVMIsGlobalConstant(value) != 0;
-    }
-    ///
-    void globalConstant(bool b)
-    {
-        LLVMSetGlobalConstant(value, b);
-    }
-}
-
-///
-class Function : GlobalValue
-{
-    /// TODO: void GetParams(ValueRef Fn, ValueRef *Params);
-    /// TODO: void GetBasicBlocks(ValueRef Fn, BasicBlockRef *BasicBlocks);
-
-    ///
-    package this(LLVMValueRef v, Type t) {
-        super(v, t);
-    }
-    ///
-    void eraseFromParent()
-    {
-        LLVMDeleteFunction(value);
-    }
-    ///
-    uint numParams()
-    {
-        return LLVMCountParams(value);
-    }
-    ///
-    Value getParam(uint idx)
-    {
-        auto v = LLVMGetParam(value, idx);
-        assert(v !is null);
-        return getValueOf(v);
-    }
-    ///
-    uint intrinsicID()
-    {
-        return LLVMGetIntrinsicID(value);
-    }
-    ///
-    uint callConv()
-    {
-        return LLVMGetFunctionCallConv(value);
-    }
-    ///
-    void callConv(uint cc)
-    {
-        LLVMSetFunctionCallConv(value, cc);
-    }
-    ///
-    char[] gc()
-    {
-        return from_stringz(LLVMGetGC(value));
-    }
-    ///
-    void gc(char[] name)
-    {
-        LLVMSetGC(value, to_stringz(name));
-    }
-    ///
-    uint numBasicBlocks()
-    {
-        return LLVMCountBasicBlocks(value);
-    }
-    ///
-    static BasicBlock InsertBasicBlock(BasicBlock bb, char[] name)
-    {
-        auto b = LLVMInsertBasicBlock(bb.bb, to_stringz(name));
-        assert(b !is null);
-        return new BasicBlock(b);
-    }
-    ///
-    BasicBlock appendBasicBlock(char[] name)
-    {
-        auto b = LLVMAppendBasicBlock(value, to_stringz(name));
-        assert(b !is null);
-        return new BasicBlock(b);
-    }
-    ///
-    BasicBlock getEntryBasicBlock()
-    {
-        auto b = LLVMGetEntryBasicBlock(value);
-        if (b is null) return null;
-        return new BasicBlock(b);
-    }
-    /// Throws an exception if the function doesn't pass the LLVM verifier.
-    void verify()
-    {
-        if (LLVMVerifyFunction(value, LLVMVerifierFailureAction.ReturnStatus))
-        {
-            auto exceptionmsg = "Function failed to verify (" ~ name ~ ")";
-            throw new LLVMException(exceptionmsg);
-        }
-    }
-}
-
-///
-class BasicBlock
-{
-    ///
-    LLVMBasicBlockRef bb;
-    ///
-    this(LLVMBasicBlockRef b)
-    {
-        assert(b !is null);
-        bb = b;
-    }
-    ///
-    this(Value v)
-    {
-        assert(LLVMValueIsBasicBlock(v.value));
-        bb = LLVMValueAsBasicBlock(v.value);
-    }
-    ///
-    override int opEquals(Object o) {
-        auto block = cast(BasicBlock) o;
-        if (!block)
-            return false;
-        return bb == block.bb;
-    }
-    ///
-    void dispose()
-    {
-        LLVMDeleteBasicBlock(bb);
-        bb = null;
-    }
-    ///
-    Function getParent() {
-        assert(bb !is null);
-        auto func = LLVMGetBasicBlockParent(bb);
-        if (!func) return null;
-        return new Function(func, getTypeOf(func));
-    }
-    ///
-    Value asValue()
-    {
-        assert(bb !is null);
-        auto v = LLVMBasicBlockAsValue(bb);
-        return new Value(v, Type.Label);
-    }
-    ///
-    bool terminated()
-    {
-        assert(bb !is null);
-        return (LLVMIsTerminated(bb) != 0);
-    }
-    ///
-    bool hasPredecessors()
-    {
-        assert(bb !is null);
-        return (LLVMHasPredecessors(bb) != 0);
-    }
-    ///
-    bool empty()
-    {
-        assert(bb !is null);
-        return (LLVMIsBasicBlockEmpty(bb) != 0);
-    }
-}
-
-///
-class TargetData
-{
-    ///
-    private LLVMTargetDataRef target;
-    ///
-    private this(LLVMTargetDataRef td)
-    {
-        target = td;
-    }
-    ///
-    static TargetData Get(char[] str)
-    {
-        return new TargetData(LLVMCreateTargetData(to_stringz(str)));
-    }
-    ///
-    static TargetData Get(Module M)
-    {
-        return new TargetData(LLVMCreateTargetData(to_stringz(M.dataLayout)));
-    }
-    /// invalidates object
-    void dispose()
-    {
-        LLVMDisposeTargetData(target);
-        target = null;
-    }
-    ///
-    size_t getABITypeSize(Type T)
-    {
-        return LLVMABISizeOfType(target, T.ll);
-    }
-}
--- a/tools/binding/llvm/type.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,587 +0,0 @@
-// Written in the D programming language by Tomas Lindquist Olsen 2008
-// Binding of llvm.c.Core types for D.
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-module llvm.type;
-
-import llvm.c.Core;
-import llvm.c.Ext;
-
-import llvm.util;
-
-// we need free
-version(Tango) {
-    import tango.stdc.stdlib;
-}
-else {
-    import std.c.stdlib;
-}
-
-
-/**
- * Each value in the IR has a type, an instance of [lltype]. See the
- * llvm::Type class.
- */
-class Type
-{
-    /// global registry for 1:1 mapping of LLVMTypeRef's -> Type's
-    private static Type[LLVMTypeRef] registry;
-    ///
-    alias LLVMTypeKind Kind;
-    ///
-    private LLVMTypeRef type;
-    // used to detect if the kind of type has changed after refinement
-    private const Kind cached_kind;
-    ///
-    private this(LLVMTypeRef t) {
-        assert(t !is null);
-        type = t;
-        cached_kind = kind;
-        assert((t in registry) is null, "Duplicate type");
-        registry[t] = this;
-        if (isAbstract())
-            registerAbstractType();
-    }
-    ///
-    void registerAbstractType() {
-        static extern(C) void onTypeRefine(void* old, LLVMTypeRef newTypeRef) {
-            Type T = cast(Type) old;
-            registry.remove(T.type);
-            
-            if (LLVMGetTypeKind(newTypeRef) == T.cached_kind) {
-                // The kind of type didn't change, so try to update and
-                // recycle the Type by updating the LLVMTypeRef.
-                T.type = newTypeRef;
-                if (newTypeRef in registry) {
-                    // We can't update the Type if it already exists
-                    // but is abstract since doing so requires we pass
-                    // a pointer to an object that will be stored where
-                    // the GC can't see it. (If it's not in the registry
-                    // it's safe because we'll put a reference in there
-                    // for the GC to find, and if it's not abstract
-                    // there's no need for the pointer to get out)
-                    if (T.isAbstract())
-                        T.type = null;
-                } else {
-                    registry[newTypeRef] = T;
-                    // This callback only gets called once per type. If
-                    // we recycle the old Type object for another
-                    // abstract type we need to re-register it with the
-                    // new LLVMTypeRef.
-                    if (T.isAbstract())
-                        T.registerAbstractType();
-                }
-            } else {
-                // Kind of type has changed, invalidate the old object.
-                T.type = null;
-                // The new Type will get entered into the registry when
-                // it's first needed.
-            }
-        }
-        
-        // Make sure we there's a reference to the passed object that
-        // the GC can see in the registry.
-        auto p = this.type in registry;
-        assert((p !is null) && (*p is this), "Can't safely register an abstract type that isn't in the registry");
-        
-        LLVMRegisterAbstractTypeCallback(this.type,
-                                         cast(void*) *p,
-                                         &onTypeRefine);
-    }
-    ///
-    char[] toString() {
-        auto cstr = LLVMTypeToString(type);
-        auto result = from_stringz(cstr).dup;
-        free(cstr);
-        return result;
-    }
-    ///
-    Kind kind() {
-        return LLVMGetTypeKind(type);
-    }
-    ///
-    bool isAbstract() {
-        return LLVMIsTypeAbstract(type) != 0;
-    }
-    /** Note: may invalidate the current object. Returns the refined Type
-     *  if it can, or null otherwise.
-     */
-    Type refineAbstractType(Type to) {
-        assert(isAbstract());
-        
-        LLVMRefineType(type, to.type);
-        
-        // Either type will do. Go through the registry to try to use the
-        // "canonical" Type object for the type.
-        if (type != null && to.type != null) {
-            assert(type == to.type, "After refinement they should be equal, right?");
-            return registry[type];
-        } else if (type != null) {
-            return registry[type];
-        } else if (to.type != null) {
-            return registry[to.type];
-        }
-        // Both types were invalidated. Is this even possible?
-        return null;
-    }
-    ///
-    static IntegerType IntType(uint bits) {
-        return IntegerType.Get(bits);
-    }
-    ///
-    static const Type Void,Label;
-    ///
-    static const IntegerType Int1, Int8, Int16, Int32, Int64, Size_t;
-    ///
-    static const RealType Float,Double,X86_FP80, FP128, PPC_FP128;
-    ///
-    static this()
-    {
-        Void = new Type(LLVMVoidType());
-        Label = new Type(LLVMLabelType());
-
-        Int1  = new IntegerType(LLVMInt1Type());
-        Int8  = new IntegerType(LLVMInt8Type());
-        Int16 = new IntegerType(LLVMInt16Type());
-        Int32 = new IntegerType(LLVMInt32Type());
-        Int64 = new IntegerType(LLVMInt64Type());
-        if (size_t.sizeof == 4)
-            Size_t = Int32;
-        else
-            Size_t = Int64;
-
-        Float     = new RealType(LLVMFloatType());
-        Double    = new RealType(LLVMDoubleType());
-        X86_FP80  = new RealType(LLVMX86FP80Type());
-        FP128     = new RealType(LLVMFP128Type());
-        PPC_FP128 = new RealType(LLVMPPCFP128Type());
-    }
-    ///
-    LLVMTypeRef ll()
-    {
-        return type;
-    }
-    ///
-    void dump()
-    {
-        LLVMDumpType(type);
-    }
-    ///
-    bool isBasic()
-    {
-        auto k = kind;
-        if (k == Kind.Struct || k == Kind.Array || k == Kind.Function)
-            return false;
-        return true;
-    }
-}
-
-///
-class IntegerType : Type
-{
-    ///
-    private this(LLVMTypeRef t)
-    {
-        super(t);
-    }
-    ///
-    static IntegerType Get(uint nbits)
-    {
-        if (nbits == 1)
-            return Type.Int1;
-        else if (nbits == 8)
-            return Type.Int8;
-        else if (nbits == 16)
-            return Type.Int16;
-        else if (nbits == 32)
-            return Type.Int32;
-        else if (nbits == 64)
-            return Type.Int64;
-        else
-        {
-            auto t = LLVMIntType(nbits);
-            auto ptr = t in registry;
-            if (ptr !is null)
-                return cast(IntegerType)*ptr;
-            auto it = new IntegerType(t);
-            return it;
-        }
-    }
-    ///
-    uint numBits()
-    {
-        return LLVMGetIntTypeWidth(type);
-    }
-}
-
-///
-class RealType : Type
-{
-    ///
-    private this(LLVMTypeRef t)
-    {
-        super(t);
-    }
-}
-
-///
-class FunctionType : Type
-{
-    ///
-    private Type ret;
-    private const Type[] params;
-    ///
-    protected this(LLVMTypeRef t, Type r, Type[] pars)
-    {
-        super(t);
-        ret = r;
-        params = pars;
-    }
-    ///
-    static FunctionType Get(Type r, Type[] pars, bool vararg=false)
-    {
-        auto p = new LLVMTypeRef[pars.length];
-        foreach(i,v; pars) p[i] = v.ll;
-        auto t = LLVMFunctionType(r.ll, p.ptr, p.length, vararg);
-        auto ptr = t in registry;
-        if (ptr !is null)
-            return cast(FunctionType)*ptr;
-        auto ft = new FunctionType(t, r, pars);
-        return ft;
-    }
-    ///
-    bool isVarArg()
-    {
-        return (LLVMIsFunctionVarArg(type) != 0);
-    }
-    ///
-    Type returnType()
-    {
-        if (!ret.type)
-            ret = getTypeOf(LLVMGetReturnType(type));
-        
-        return ret;
-    }
-    ///
-    Type[] paramTypes()
-    {
-        foreach (par ; params) {
-            if (!par.type) {
-                updateParams();
-            }
-        }
-        return params;
-    }
-    ///
-    Type getParamType(uint idx)
-    {
-        auto par = params[idx];
-        if (!par.type) {
-            updateParams();
-            par = params[idx];
-        }
-        return params[idx];
-    }
-    ///
-    uint numParams()
-    {
-        return params.length;
-    }
-    /** Called when one or more of the parameter types have been
-     *  invalidated.
-     */
-    private void updateParams() {
-        assert (LLVMCountParamTypes(type) == params.length);
-        auto llparams = new LLVMTypeRef[params.length];
-        LLVMGetParamTypes(type, llparams.ptr);
-        foreach (idx, llpar ; llparams) {
-            params[idx] = getTypeOf(llpar);
-        }
-    }
-}
-
-///
-class StructType : Type
-{
-    ///
-    private this(LLVMTypeRef t)
-    {
-        super(t);
-    }
-    ///
-    static StructType Get(Type[] elems, bool packed=false)
-    {
-        auto tys = new LLVMTypeRef[elems.length];
-        foreach(i,e; elems) tys[i] = e.ll;
-        auto t = LLVMStructType(tys.ptr, tys.length, packed);
-        auto ptr = t in registry;
-        if (ptr !is null)
-            return cast(StructType)*ptr;
-        auto st = new StructType(t);
-        return st;
-    }
-    ///
-    bool packed()
-    {
-        return (LLVMIsPackedStruct(type) != 0);
-    }
-    ///
-    uint numElements()
-    {
-        return LLVMCountStructElementTypes(type);
-    }
-    ///
-    Type[] elementTypes()
-    {
-        auto n = numElements();
-        auto dst = new LLVMTypeRef[n];
-        LLVMGetStructElementTypes(type, dst.ptr);
-        auto e = new Type[n];
-        for(auto i=0; i<n; i++)
-            e[i] = getTypeOf(dst[i]);
-        return e;
-    }
-}
-
-///
-abstract class SequenceType : Type
-{
-    ///
-    private Type elemty;
-    ///
-    private this(LLVMTypeRef t, Type elemty)
-    {
-        super(t);
-        this.elemty = elemty;
-    }
-    ///
-    Type elementType()
-    {
-        if (!elemty.type)
-            elemty = getTypeOf(LLVMGetElementType(type));
-        return elemty;
-    }
-}
-
-///
-class PointerType : SequenceType
-{
-    ///
-    private const uint addrSpace;
-    ///
-    protected this(LLVMTypeRef t, Type e, uint as)
-    {
-        super(t, e);
-        addrSpace = as;
-    }
-    ///
-    static PointerType Get(Type e, uint as=0)
-    {
-        auto t = LLVMPointerType(e.ll, as);
-        auto ptr = t in registry;
-        if (ptr !is null)
-            return cast(PointerType)*ptr;
-        auto pt = new PointerType(t, e, as);
-        return pt;
-    }
-    ///
-    uint addressSpace()
-    {
-        return addrSpace;
-    }
-}
-
-///
-class ArrayType : SequenceType
-{
-    ///
-    private const uint arrlen;
-    ///
-    protected this(LLVMTypeRef t, Type e, uint l)
-    {
-        super(t, e);
-        arrlen = l;
-    }
-    ///
-    static ArrayType Get(Type e, uint l)
-    {
-        auto t = LLVMArrayType(e.ll, l);
-        auto ptr = t in registry;
-        if (ptr !is null) return cast(ArrayType)*ptr;
-        auto at = new ArrayType(t, e, l);
-        return at;
-    }
-    ///
-    uint length()
-    {
-        return arrlen;
-    }
-}
-
-///
-class VectorType : SequenceType
-{
-    ///
-    private const uint vecsz;
-    ///
-    protected this(LLVMTypeRef t, Type e, uint s)
-    {
-        super(t, e);
-        vecsz = s;
-    }
-    ///
-    static VectorType Get(Type e, uint s)
-    {
-        auto t = LLVMVectorType(e.ll, s);
-        auto ptr = t in registry;
-        if (ptr !is null) return cast(VectorType)*ptr;
-        auto at = new VectorType(t, e, s);
-        return at;
-    }
-    ///
-    uint vectorSize()
-    {
-        return vecsz;
-    }
-}
-
-///
-class OpaqueType : Type
-{
-    ///
-    private this(LLVMTypeRef t)
-    {
-        super(t);
-    }
-    ///
-    static OpaqueType Get()
-    {
-        auto t = LLVMOpaqueType();
-        auto ot = new OpaqueType(t);
-        return ot;
-    }
-    ///
-    private static OpaqueType Get(LLVMTypeRef t)
-    {
-        auto ptr = t in registry;
-        if (ptr !is null)
-            return cast(OpaqueType)*ptr;
-        auto ot = new OpaqueType(t);
-        return ot;
-    }
-}
-
-///
-class TypeHandle
-{
-    ///
-    private LLVMTypeHandleRef handle;
-    ///
-    this()
-    {
-        handle = LLVMCreateTypeHandle(LLVMOpaqueType());
-    }
-    ///
-    Type resolve()
-    {
-        assert(handle !is null);
-        auto t = LLVMResolveTypeHandle(handle);
-        return getTypeOf(t);
-    }
-    ///
-    void refine(Type to)
-    {
-        assert(handle !is null);
-        auto t = LLVMResolveTypeHandle(handle);
-        LLVMRefineType(t, to.ll);
-    }
-    ///
-    void dispose()
-    {
-        assert(handle !is null);
-        LLVMDisposeTypeHandle(handle);
-        handle = null;
-    }
-    ///
-    ~this()
-    {
-        if (handle)
-        {
-            // Safe because handle isn't on the GC heap and isn't exposed.
-            dispose();
-        }
-    }
-}
-
-///
-Type getTypeOf(LLVMValueRef v)
-{
-    return getTypeOf(LLVMTypeOf(v));
-}
-
-///
-Type getTypeOf(LLVMTypeRef ty)
-{
-    // first check the registry
-    auto ptr = ty in Type.registry;
-    if (ptr !is null) return *ptr;
-
-    // reconstruct D type from C type and query it
-    auto kind = LLVMGetTypeKind(ty);
-    switch(kind)
-    {
-    case Type.Kind.Integer:
-        auto bw = LLVMGetIntTypeWidth(ty);
-        return Type.IntType(bw);
-
-    case Type.Kind.Pointer:
-        auto e = LLVMGetElementType(ty);
-        auto a = LLVMGetPointerAddressSpace(ty);
-        return PointerType.Get(getTypeOf(e), a);
-
-    case Type.Kind.Struct:
-        auto t = new StructType(ty);
-        return t;
-        // was broken for recursive types ...
-        /*auto n = LLVMCountStructElementTypes(ty);
-        auto e = new LLVMTypeRef[n];
-        LLVMGetStructElementTypes(ty, e.ptr);
-        auto p = LLVMIsPackedStruct(ty);
-        auto t = new Type[n];
-        foreach(i,et; e) t[i] = getTypeOf(et);
-        return StructType.Get(t,p!=0);*/
-
-    case Type.Kind.Opaque:
-        return OpaqueType.Get(ty);
-
-    case Type.Kind.Function:
-        auto llr = LLVMGetReturnType(ty);
-        auto lla = new LLVMTypeRef[LLVMCountParamTypes(ty)];
-        LLVMGetParamTypes(ty, lla.ptr);
-        auto args = new Type[lla.length];
-        foreach(i,a; lla) args[i] = getTypeOf(a);
-        int isvararg = LLVMIsFunctionVarArg(ty);
-        return FunctionType.Get(getTypeOf(llr), args, isvararg!=0);
-
-    case Type.Kind.Array:
-        auto lle = LLVMGetElementType(ty);
-        auto len = LLVMGetArrayLength(ty);
-        return ArrayType.Get(getTypeOf(lle), len);
-
-    case Type.Kind.Vector:
-        auto lle = LLVMGetElementType(ty);
-        auto sz = LLVMGetVectorSize(ty);
-        return VectorType.Get(getTypeOf(lle), sz);
-
-    case Type.Kind.Void:
-    case Type.Kind.Float:
-    case Type.Kind.Double:
-    case Type.Kind.X86_FP80:
-    case Type.Kind.FP128:
-    case Type.Kind.PPC_FP128:
-    case Type.Kind.Label:
-        assert(0, "basic type not in registry");
-    }
-}
--- a/tools/binding/llvm/util.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,30 +0,0 @@
-// Written in the D programming language by Tomas Lindquist Olsen 2008
-// Binding of llvm.c.Core values for D.
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-module llvm.util;
-
-//we need <cstring>
-version(Tango) {
-    import tango.stdc.string;
-}
-else {
-    import std.c.string;
-}
-
-///
-char[] from_stringz(char* p)
-{
-    if (p is null)
-        return "";
-    return p[0..strlen(p)];
-}
-
-///
-char* to_stringz(char[] s)
-{
-    return (s~\0).ptr;
-}
-
--- a/tools/binding/llvmsample1.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,47 +0,0 @@
-// simple hello world sample of D LLVM
-module llvmsample1;
-
-import llvm.llvm;
-
-void main()
-{
-    // create module
-    auto m = new Module("sample1");
-    scope(exit) m.dispose();
-
-    // declare string
-    auto chello = ConstantArray.GetString("Hello World!\n", true);
-    auto hello = m.addGlobal(chello.type, "hellostring");
-    hello.initializer = chello;
-    hello.linkage = Linkage.Internal;
-    hello.globalConstant = true;
-
-    // declare printf
-    auto printfType = FunctionType.Get(Type.Int32, [ PointerType.Get(Type.Int8) ], true);
-    auto llprintf = m.addFunction(printfType, "printf");
-
-    // declare main
-    auto mainType = FunctionType.Get(Type.Int32, null);
-    auto llmain = m.addFunction(mainType, "main");
-
-    // create builder
-    auto b = new Builder;
-    scope(exit) b.dispose();
-
-    // create main body block
-    auto bb = llmain.appendBasicBlock("entry");
-    b.positionAtEnd(bb);
-
-    // call printf
-    auto zero = ConstantInt.GetU(Type.Int32, 0);
-    auto helloptr = b.buildGEP(hello, [ zero, zero ], "str");
-    helloptr.dump();
-    auto args = [ helloptr ];
-    auto call = b.buildCall(llprintf, args, "");
-
-    // return 0
-    b.buildRet(ConstantInt.GetS(Type.Int32, 0));
-
-    // write bitcode
-    m.writeBitcodeToFile("sample1.bc");
-}
--- a/tools/binding/llvmsample2.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,18 +0,0 @@
-// simple test of recursive types.
-module llvmsample2;
-
-import llvm.llvm;
-
-void main()
-{
-    auto th = new TypeHandle();
-    auto s = StructType.Get([ PointerType.Get(th.resolve) ], false);
-    th.refine(s);
-    s.dump();
-    th.dispose();
-
-    auto t = getTypeOf(s.ll);
-    t.dump();
-
-    assert(s is t);
-}
--- a/tools/binding/llvmsample3.d	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,35 +0,0 @@
-// simple example that shows off getting D wrappers from C values.
-module llvmsample3;
-
-import llvm.c.Core;
-import llvm.llvm;
-
-void main()
-{
-    auto m = new Module("sample3");
-
-    // global int32
-    auto gi = m.addGlobal(Type.Int32, "myint");
-    gi.initializer = ConstantInt.GetU(Type.Int32, 42);
-
-    // this is not a cached value, it's recreated dynamically
-    auto _i = gi.initializer;
-    auto ci = cast(ConstantInt)_i;
-    assert(ci !is null);
-    ci.dump;
-
-    // global struct
-    auto st = StructType.Get([Type.Double,Type.Double,Type.Double]);
-    auto gs = m.addGlobal(st, "mystruct");
-    auto elems = new Constant[3];
-    foreach(i,ref e; elems)
-        e = ConstantReal.Get(Type.Double, i+1);
-    gs.initializer = ConstantStruct.Get(elems);
-
-    // again this is not a cached value.
-    auto s = gs.initializer;
-    auto cs = cast(ConstantStruct)s;
-    assert(cs !is null);
-
-    cs.dump;
-}
--- a/tools/binding/prebuild.sh	Wed May 19 12:42:32 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,9 +0,0 @@
-#!/bin/sh
-
-g++ llvm-ext.cpp -c `llvm-config --cxxflags`
-g++ llvm-opt.cpp -c `llvm-config --cxxflags`
-g++ llvm-typemonitor.cpp -c `llvm-config --cxxflags`
-
-rm -f libllvm-c-ext.a
-ar rc libllvm-c-ext.a llvm-ext.o llvm-opt.o llvm-typemonitor.o
-ranlib libllvm-c-ext.a