--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/runtime/ldc.diff	Mon Oct 06 22:56:54 2008 +0200
@@ -0,0 +1,711 @@
+Index: object.di
+===================================================================
+--- object.di	(revision 3954)
++++ object.di	(working copy)
+@@ -150,6 +150,9 @@
+     void function() dtor;
+     void function() unitTest;
+ 
++    void* xgetMembers;
++    void function() ictor;
++
+     static int opApply( int delegate( inout ModuleInfo ) );
+ }
+ 
+Index: lib/common/tango/core/BitManip.d
+===================================================================
+--- lib/common/tango/core/BitManip.d	(revision 3954)
++++ lib/common/tango/core/BitManip.d	(working copy)
+@@ -171,6 +171,10 @@
+      */
+     uint outpl( uint port_address, uint value );
+ }
++else version( LDC )
++{
++    public import ldc.bitmanip;
++}
+ else
+ {
+     public import std.intrinsic;
+Index: lib/common/tango/core/Thread.d
+===================================================================
+--- lib/common/tango/core/Thread.d	(revision 3954)
++++ lib/common/tango/core/Thread.d	(working copy)
+@@ -244,8 +244,29 @@
+         }
+         body
+         {
+-            version( D_InlineAsm_X86 )
++            version( LDC)
+             {
++                version(X86)
++                {
++                    uint eax,ecx,edx,ebx,ebp,esi,edi;
++                    asm
++                    {
++                        mov eax[EBP], EAX      ;
++                        mov ecx[EBP], ECX      ;
++                        mov edx[EBP], EDX      ;
++                        mov ebx[EBP], EBX      ;
++                        mov ebp[EBP], EBP      ;
++                        mov esi[EBP], ESI      ;
++                        mov edi[EBP], EDI      ;
++                    }
++                }
++                else
++                {
++                    static assert( false, "Architecture not supported." );
++                }
++            }
++            else version( D_InlineAsm_X86 )
++            {
+                 asm
+                 {
+                     pushad;
+@@ -297,8 +318,12 @@
+                 }
+             }
+ 
+-            version( D_InlineAsm_X86 )
++            version( LDC)
+             {
++                // nothing to pop
++            }
++            else version( D_InlineAsm_X86 )
++            {
+                 asm
+                 {
+                     popad;
+@@ -2286,6 +2311,13 @@
+             version = AsmPPC_Posix;
+     }
+ 
++    version( LLVM_InlineAsm_X86 )
++    {
++        version( Win32 )
++            version = LLVM_AsmX86_Win32;
++        else version( Posix )
++            version = LLVM_AsmX86_Posix;
++    }
+ 
+     version( Posix )
+     {
+@@ -2296,6 +2328,8 @@
+         version( AsmX86_Win32 ) {} else
+         version( AsmX86_Posix ) {} else
+         version( AsmPPC_Posix ) {} else
++        version( LLVM_AsmX86_Win32 ) {} else
++        version( LLVM_AsmX86_Posix ) {} else
+         {
+             // NOTE: The ucontext implementation requires architecture specific
+             //       data definitions to operate so testing for it must be done
+@@ -2306,10 +2340,10 @@
+             import tango.stdc.posix.ucontext;
+         }
+     }
+-
+-    const size_t PAGESIZE;
+ }
+ 
++// this can't be private since it's used as default argument to a public function
++const size_t PAGESIZE;
+ 
+ static this()
+ {
+@@ -2336,7 +2370,7 @@
+     }
+ }
+ 
+-
++extern(C) int printf(char*, ...);
+ ////////////////////////////////////////////////////////////////////////////////
+ // Fiber Entry Point and Context Switch
+ ////////////////////////////////////////////////////////////////////////////////
+@@ -2450,6 +2484,22 @@
+                 ret;
+             }
+         }
++        else version( LLVM_AsmX86_Posix )
++        {
++            asm
++            {
++                // clobber registers to save
++                inc EBX;
++                inc ESI;
++                inc EDI;
++
++                // store oldp again with more accurate address
++                mov EAX, oldp;
++                mov [EAX], ESP;
++                // load newp to begin context switch
++                mov ESP, newp;
++            }
++        }
+         else static if( is( ucontext_t ) )
+         {
+             Fiber   cfib = Fiber.getThis();
+@@ -3115,6 +3165,16 @@
+             push( 0x00000000 );                                     // ESI
+             push( 0x00000000 );                                     // EDI
+         }
++        else version( LLVM_AsmX86_Posix )
++        {
++            push( cast(size_t) &fiber_entryPoint );                 // EIP
++            push( 0x00000000 );                                     // newp
++            push( 0x00000000 );                                     // oldp
++            push( 0x00000000 );                                     // EBP
++            push( 0x00000000 );                                     // EBX
++            push( 0x00000000 );                                     // ESI
++            push( 0x00000000 );                                     // EDI
++        }
+         else version( AsmPPC_Posix )
+         {
+             version( StackGrowsDown )
+Index: lib/unittest.sh
+===================================================================
+--- lib/unittest.sh	(revision 3954)
++++ lib/unittest.sh	(working copy)
+@@ -18,8 +18,9 @@
+   --help: This message
+   --run-all: Reports result instead of breaking. Do not use this if you want to
+          run unittest runner through a debugger.
+-  dmd: Builds unittests for dmd
+-  gdc: Builds unittests for gdc
++  dmd:    Builds unittests for dmd
++  gdc:    Builds unittests for gdc
++  ldc: Builds unittests for ldc
+ 
+   <none>: Builds unittests for all known compilers.'
+   exit 0
+@@ -86,7 +87,7 @@
+ void main() {}
+ EOF
+ 
+-        rebuild -w -d -g -L-ldl -L-lz -L-lbz2 -debug=UnitTest -debug -full -clean -unittest \
++        rebuild -w -d -L-ldl -L-lz -L-lbz2 -debug=UnitTest -debug -full -clean -unittest \
+         -version=UnitTest $EXE.d tango/core/*.d tango/core/sync/*.d tango/io/digest/*.d \
+         tango/io/model/*.d tango/io/protocol/*.d tango/io/selector/*.d tango/io/*.d \
+         tango/io/vfs/*.d tango/io/vfs/model/*.d \
+@@ -125,6 +126,9 @@
+         gdc)
+             GDC=1
+             ;;
++        ldc)
++            LDC=1
++            ;;
+         *)
+             usage
+             ;;
+@@ -132,10 +136,11 @@
+     shift
+ done
+ 
+-if [ ! "$DMD" -a ! "$GDC" ]
++if [ ! "$DMD" -a ! "$GDC" -a ! "$LDC" ]
+ then
+     DMD=1
+     GDC=1
++    LDC=1
+ fi
+ 
+ if [ "$DMD" = "1" ]
+@@ -146,4 +151,7 @@
+ then
+     compile gdc runUnitTest_gdc
+ fi
+-
++if [ "$LDC" = "1" ]
++then
++    compile ldc runUnitTest_ldc
++fi
+Index: lib/gc/basic/gcx.d
+===================================================================
+--- lib/gc/basic/gcx.d	(revision 3954)
++++ lib/gc/basic/gcx.d	(working copy)
+@@ -65,6 +65,13 @@
+ }
+ 
+ 
++struct BlkInfo
++{
++    void*  base;
++    size_t size;
++    uint   attr;
++}
++
+ private
+ {
+     enum BlkAttr : uint
+@@ -75,13 +82,6 @@
+         ALL_BITS = 0b1111_1111
+     }
+ 
+-    struct BlkInfo
+-    {
+-        void*  base;
+-        size_t size;
+-        uint   attr;
+-    }
+-
+     extern (C) void* rt_stackBottom();
+     extern (C) void* rt_stackTop();
+ 
+@@ -2178,6 +2178,28 @@
+             __builtin_unwind_init();
+             sp = & sp;
+         }
++        else version(LDC)
++        {
++            version(X86)
++            {
++                uint eax,ecx,edx,ebx,ebp,esi,edi;
++                asm
++                {
++                    mov eax[EBP], EAX      ;
++                    mov ecx[EBP], ECX      ;
++                    mov edx[EBP], EDX      ;
++                    mov ebx[EBP], EBX      ;
++                    mov ebp[EBP], EBP      ;
++                    mov esi[EBP], ESI      ;
++                    mov edi[EBP], EDI      ;
++                    mov sp[EBP],ESP     ;
++                }
++            }
++            else
++            {
++                static assert( false, "Architecture not supported." );
++            }
++        }
+         else
+         {
+         asm
+@@ -2191,6 +2213,10 @@
+         {
+             // nothing to do
+         }
++        else version(LDC)
++        {
++            // nothing to do
++        }
+         else
+         {
+         asm
+Index: lib/gc/basic/gcbits.d
+===================================================================
+--- lib/gc/basic/gcbits.d	(revision 3954)
++++ lib/gc/basic/gcbits.d	(working copy)
+@@ -39,6 +39,10 @@
+ {
+     // use the unoptimized version
+ }
++else version(LDC)
++{
++    // ditto
++}
+ else version (D_InlineAsm_X86)
+ {
+     version = Asm86;
+Index: tango/text/convert/Layout.d
+===================================================================
+--- tango/text/convert/Layout.d	(revision 3954)
++++ tango/text/convert/Layout.d	(working copy)
+@@ -47,6 +47,12 @@
+         alias void* Arg;
+         alias va_list ArgList;
+         }
++else version(LDC)
++        {
++        private import tango.core.Vararg;
++        alias void* Arg;
++        alias va_list ArgList;
++        }
+      else
+         {
+         alias void* Arg;
+@@ -197,9 +203,18 @@
+                 assert (formatStr, "null format specifier");
+                 assert (arguments.length < 64, "too many args in Layout.convert");
+ 
+-                version (GNU)
++                version (LDC)
+                         {
+                         Arg[64] arglist = void;
++                        foreach (i, arg; arguments)
++                                {
++                                arglist[i] = args;
++                                args += (arg.tsize + size_t.sizeof - 1) & ~ (size_t.sizeof - 1);
++                                }
++                        }
++                else version (GNU)
++                        {
++                        Arg[64] arglist = void;
+                         int[64] intargs = void;
+                         byte[64] byteargs = void;
+                         long[64] longargs = void;
+Index: tango/core/Vararg.d
+===================================================================
+--- tango/core/Vararg.d	(revision 3954)
++++ tango/core/Vararg.d	(working copy)
+@@ -15,6 +15,10 @@
+ {
+     public import std.stdarg;
+ }
++else version( LDC )
++{
++    public import ldc.vararg;
++}
+ else
+ {
+     /**
+Index: tango/core/Atomic.d
+===================================================================
+--- tango/core/Atomic.d	(revision 3954)
++++ tango/core/Atomic.d	(working copy)
+@@ -270,6 +270,167 @@
+ 
+ 
+ ////////////////////////////////////////////////////////////////////////////////
++// LDC Atomics Implementation
++////////////////////////////////////////////////////////////////////////////////
++
++
++else version( LDC )
++{
++    import ldc.intrinsics;
++
++
++    ////////////////////////////////////////////////////////////////////////////
++    // Atomic Load
++    ////////////////////////////////////////////////////////////////////////////
++
++
++    template atomicLoad( msync ms = msync.seq, T )
++    {
++        T atomicLoad(ref T val)
++        {
++            llvm_memory_barrier(
++                ms == msync.hlb || ms == msync.acq || ms == msync.seq,
++                ms == msync.hsb || ms == msync.acq || ms == msync.seq,
++                ms == msync.slb || ms == msync.rel || ms == msync.seq,
++                ms == msync.ssb || ms == msync.rel || ms == msync.seq,
++                false);
++            static if (isPointerType!(T))
++            {
++                return cast(T)llvm_atomic_load_add!(size_t)(cast(size_t*)&val, 0);
++            }
++            else static if (is(T == bool))
++            {
++                return llvm_atomic_load_add!(ubyte)(cast(ubyte*)&val, cast(ubyte)0) ? 1 : 0;
++            }
++            else
++            {
++                return llvm_atomic_load_add!(T)(&val, cast(T)0);
++            }
++        }
++    }
++
++
++    ////////////////////////////////////////////////////////////////////////////
++    // Atomic Store
++    ////////////////////////////////////////////////////////////////////////////
++
++
++    template atomicStore( msync ms = msync.seq, T )
++    {
++        void atomicStore( ref T val, T newval )
++        {
++            llvm_memory_barrier(
++                ms == msync.hlb || ms == msync.acq || ms == msync.seq,
++                ms == msync.hsb || ms == msync.acq || ms == msync.seq,
++                ms == msync.slb || ms == msync.rel || ms == msync.seq,
++                ms == msync.ssb || ms == msync.rel || ms == msync.seq,
++                false);
++            static if (isPointerType!(T))
++            {
++                llvm_atomic_swap!(size_t)(cast(size_t*)&val, cast(size_t)newval);
++            }
++            else static if (is(T == bool))
++            {
++                llvm_atomic_swap!(ubyte)(cast(ubyte*)&val, newval?1:0);
++            }
++            else
++            {
++                llvm_atomic_swap!(T)(&val, newval);
++            }
++        }
++    }
++
++
++    ////////////////////////////////////////////////////////////////////////////
++    // Atomic Store If
++    ////////////////////////////////////////////////////////////////////////////
++
++
++    template atomicStoreIf( msync ms = msync.seq, T )
++    {
++        bool atomicStoreIf( ref T val, T newval, T equalTo )
++        {
++            llvm_memory_barrier(
++                ms == msync.hlb || ms == msync.acq || ms == msync.seq,
++                ms == msync.hsb || ms == msync.acq || ms == msync.seq,
++                ms == msync.slb || ms == msync.rel || ms == msync.seq,
++                ms == msync.ssb || ms == msync.rel || ms == msync.seq,
++                false);
++            T oldval = void;
++            static if (isPointerType!(T))
++            {
++                oldval = cast(T)llvm_atomic_cmp_swap!(size_t)(cast(size_t*)&val, cast(size_t)equalTo, cast(size_t)newval);
++            }
++            else static if (is(T == bool))
++            {
++                oldval = llvm_atomic_cmp_swap!(ubyte)(cast(ubyte*)&val, equalTo?1:0, newval?1:0)?0:1;
++            }
++            else
++            {
++                oldval = llvm_atomic_cmp_swap!(T)(&val, equalTo, newval);
++            }
++            return oldval == equalTo;
++        }
++    }
++    
++    
++    ////////////////////////////////////////////////////////////////////////////
++    // Atomic Increment
++    ////////////////////////////////////////////////////////////////////////////
++
++
++    template atomicIncrement( msync ms = msync.seq, T )
++    {
++        //
++        // NOTE: This operation is only valid for integer or pointer types
++        //
++        static assert( isValidNumericType!(T) );
++
++
++        T atomicIncrement( ref T val )
++        {
++            static if (isPointerType!(T))
++            {
++                llvm_atomic_load_add!(size_t)(cast(size_t*)&val, 1);
++            }
++            else
++            {
++                llvm_atomic_load_add!(T)(&val, cast(T)1);
++            }
++            return val;
++        }
++    }
++    
++    
++    ////////////////////////////////////////////////////////////////////////////
++    // Atomic Decrement
++    ////////////////////////////////////////////////////////////////////////////
++
++
++    template atomicDecrement( msync ms = msync.seq, T )
++    {
++        //
++        // NOTE: This operation is only valid for integer or pointer types
++        //
++        static assert( isValidNumericType!(T) );
++
++
++        T atomicDecrement( ref T val )
++        {
++            static if (isPointerType!(T))
++            {
++                llvm_atomic_load_sub!(size_t)(cast(size_t*)&val, 1);
++            }
++            else
++            {
++                llvm_atomic_load_sub!(T)(&val, cast(T)1);
++            }
++            return val;
++        }
++    }
++}
++
++////////////////////////////////////////////////////////////////////////////////
+ // x86 Atomic Function Implementation
+ ////////////////////////////////////////////////////////////////////////////////
+ 
+Index: tango/math/Math.d
+===================================================================
+--- tango/math/Math.d	(revision 3954)
++++ tango/math/Math.d	(working copy)
+@@ -76,6 +76,14 @@
+         version = DigitalMars_D_InlineAsm_X86;
+     }
+ }
++else version(LDC)
++{
++    import ldc.intrinsics;
++    version(X86)
++    {
++        version = LDC_X86;
++    }
++}
+ 
+ /*
+  * Constants
+@@ -298,6 +306,24 @@
+  * Bugs:
+  *  Results are undefined if |x| >= $(POWER 2,64).
+  */
++version(LDC)
++{
++    alias llvm_cos_f32 cos;
++    alias llvm_cos_f64 cos;
++    version(X86)
++    {
++        alias llvm_cos_f80 cos;
++    }
++    else
++    {
++        real cos(real x)
++        {
++            return tango.stdc.math.cosl(x);
++        }
++    }
++}
++else
++{
+ real cos(real x) /* intrinsic */
+ {
+     version(D_InlineAsm_X86)
+@@ -313,6 +339,7 @@
+         return tango.stdc.math.cosl(x);
+     }
+ }
++}
+ 
+ debug(UnitTest) {
+ unittest {
+@@ -333,6 +360,24 @@
+  * Bugs:
+  *  Results are undefined if |x| >= $(POWER 2,64).
+  */
++version(LDC)
++{
++    alias llvm_sin_f32 sin;
++    alias llvm_sin_f64 sin;
++    version(X86)
++    {
++        alias llvm_sin_f80 sin;
++    }
++    else
++    {
++        real sin(real x)
++        {
++            return tango.stdc.math.sinl(x);
++        }
++    }
++}
++else
++{
+ real sin(real x) /* intrinsic */
+ {
+     version(D_InlineAsm_X86)
+@@ -348,6 +393,7 @@
+         return tango.stdc.math.sinl(x);
+     }
+ }
++}
+ 
+ debug(UnitTest) {
+ unittest {
+@@ -374,7 +420,11 @@
+ {
+     version (GNU) {
+         return tanl(x);
+-    } else {
++    }
++    else version(LDC) {
++        return tango.stdc.math.tanl(x);
++    }
++    else {
+     asm
+     {
+         fld x[EBP]      ; // load theta
+@@ -947,6 +997,25 @@
+  *  <tr> <td> +&infin; <td> +&infin; <td> no
+  *  )
+  */
++version(LDC)
++{
++    alias llvm_sqrt_f32 sqrt;
++    alias llvm_sqrt_f64 sqrt;
++    version(X86)
++    {
++        alias llvm_sqrt_f80 sqrt;
++    }
++    else
++    {
++        real sqrt(real x)
++        {
++            return tango.stdc.math.sqrtl(x);
++        }
++    }
++}
++else
++{
++
+ float sqrt(float x) /* intrinsic */
+ {
+     version(D_InlineAsm_X86)
+@@ -995,6 +1064,8 @@
+     }
+ }
+ 
++}
++
+ /** ditto */
+ creal sqrt(creal z)
+ {
+@@ -1477,7 +1548,14 @@
+         }
+     }
+     }
+-    return tango.stdc.math.powl(x, y);
++    version(LDC_X86)
++    {
++        return llvm_pow_f80(x, y);
++    }
++    else
++    {
++        return tango.stdc.math.powl(x, y);
++    }
+ }
+ 
+ debug(UnitTest) {
+Index: tango/stdc/stdlib.d
+===================================================================
+--- tango/stdc/stdlib.d	(revision 3954)
++++ tango/stdc/stdlib.d	(working copy)
+@@ -94,6 +94,11 @@
+ {
+     void* alloca(size_t size);
+ }
++else version( LDC )
++{
++    pragma(alloca)
++        void* alloca(size_t size);
++}
+ else version( GNU )
+ {
+     private import gcc.builtins;
+Index: tango/stdc/stdarg.d
+===================================================================
+--- tango/stdc/stdarg.d	(revision 3954)
++++ tango/stdc/stdarg.d	(working copy)
+@@ -13,6 +13,10 @@
+ {
+     public import std.c.stdarg;
+ }
++else version( LDC )
++{
++    public import ldc.cstdarg;
++}
+ else
+ {
+     alias void* va_list;