Ticket #1212: llvmdc.diff

object.di

@@ -150 +150 @@
-    void function() dtor;
-    void function() unitTest;
-
+    void* xgetMembers;
+    void function() ictor;
+
-    static int opApply( int delegate( inout ModuleInfo ) );
-}
-

lib/unittest.sh

@@ -18 +18 @@
-  --help: This message
-  --run-all: Reports result instead of breaking. Do not use this if you want to
-         run unittest runner through a debugger.
-
-
+
+
+
-
-  <none>: Builds unittests for all known compilers.'
-  exit 0
@@ -86 +87 @@
-void main() {}
-EOF
-
-g -
+
-        -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 +126 @@
-        gdc)
-            GDC=1
-            ;;
+        llvmdc)
+            LLVMDC=1
+            ;;
-        *)
-            usage
-            ;;
@@ -132 +136 @@
-    shift
-done
-
-
+-a ! "$LLVMDC" 
-then
-    DMD=1
-    GDC=1
+    LLVMDC=1
-fi
-
-if [ "$DMD" = "1" ]
@@ -146 +151 @@
-then
-    compile gdc runUnitTest_gdc
-fi
-
+
+
+
+

lib/common/tango/core/BitManip.d

@@ -171 +171 @@
-     */
-    uint outpl( uint port_address, uint value );
-}
+else version( LLVMDC )
+{
+    public import llvmdc.bitmanip;
+}
-else
-{
-    public import std.intrinsic;

lib/common/tango/core/Thread.d

@@ -255 +255 @@
-            {
-                __builtin_unwind_init();
-            }
+            else version( LLVMDC )
+            {
+                pragma(msg, "don't know how to push registers on the stack for this architecture with LLVMDC");
+            }
-            else
-            {
-                static assert( false, "Architecture not supported." );
@@ -308 +312 @@
-            {
-                // registers will be popped automatically
-            }
+            else version( LLVMDC )
+            {
+                // TODO
+            }
-            else
-            {
-                static assert( false, "Architecture not supported." );

lib/gc/basic/gcx.d

@@ -2178 +2178 @@
-            __builtin_unwind_init();
-            sp = & sp;
-        }
+        else version(LLVMDC)
+        {
+            version(X86)
+            {
+                asm
+                {
+                    pushad              ;
+                    mov sp[EBP],ESP     ;
+                }
+            }
+            else
+            {
+                pragma(msg, "don't know how to push registers on the stack for this architecture with llvmdc");
+            }
+        }
-        else
-        {
-        asm
@@ -2191 +2206 @@
-        {
-            // nothing to do
-        }
+        else version(LLVMDC)
+        {
+            version(X86)
+            {
+                asm
+                {
+                    popad               ;
+                }
+            }
+            else
+            {
+                // TODO
+            }
+        }
-        else
-        {
-        asm

lib/gc/basic/gcbits.d

@@ -39 +39 @@
-{
-    // use the unoptimized version
-}
+else version(LLVMDC)
+{
+    // ditto
+}
-else version (D_InlineAsm_X86)
-{
-    version = Asm86;

tango/text/convert/Layout.d

@@ -47 +47 @@
-        alias void* Arg;
-        alias va_list ArgList;
-        }
+else version(LLVMDC)
+        {
+        private import tango.core.Vararg;
+        alias void* Arg;
+        alias va_list ArgList;
+        }
-     else
-        {
-        alias void* Arg;
@@ -197 +203 @@
-                assert (formatStr, "null format specifier");
-                assert (arguments.length < 64, "too many args in Layout.convert");
-
-GNU
+LLVMDC
-                        {
-                        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;

tango/core/Vararg.d

@@ -15 +15 @@
-{
-    public import std.stdarg;
-}
+else version( LLVMDC )
+{
+    public import llvmdc.vararg;
+}
-else
-{
-    /**

tango/core/Atomic.d

@@ -270 +270 @@
-
-
-////////////////////////////////////////////////////////////////////////////////
+// LLVMDC Atomics Implementation
+////////////////////////////////////////////////////////////////////////////////
+
+
+else version( LLVMDC )
+{
+    import llvmdc.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
+            {
+                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))
+            {
+                return cast(T)llvm_atomic_load_add!(size_t)(cast(size_t*)&val, 1);
+            }
+            else
+            {
+                return llvm_atomic_load_add!(T)(&val, cast(T)1);
+            }
+        }
+    }
+    
+    
+    ////////////////////////////////////////////////////////////////////////////
+    // 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))
+            {
+                return cast(T)llvm_atomic_load_sub!(size_t)(cast(size_t*)&val, 1);
+            }
+            else
+            {
+                return llvm_atomic_load_sub!(T)(&val, cast(T)1);
+            }
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
-// x86 Atomic Function Implementation
-////////////////////////////////////////////////////////////////////////////////
-

tango/math/Math.d

@@ -76 +76 @@
-        version = DigitalMars_D_InlineAsm_X86;
-    }
-}
+else version(LLVMDC)
+{
+    import llvmdc.intrinsics;
+    version(X86)
+    {
+        version = LLVMDC_X86;
+    }
+}
-
-/*
- * Constants
@@ -298 +306 @@
- * Bugs:
- *  Results are undefined if |x| >= $(POWER 2,64).
- */
+version(LLVMDC)
+{
+    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 +339 @@
-        return tango.stdc.math.cosl(x);
-    }
-}
+}
-
-debug(UnitTest) {
-unittest {
@@ -333 +360 @@
- * Bugs:
- *  Results are undefined if |x| >= $(POWER 2,64).
- */
+version(LLVMDC)
+{
+    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 +393 @@
-        return tango.stdc.math.sinl(x);
-    }
-}
+}
-
-debug(UnitTest) {
-unittest {
@@ -374 +420 @@
-{
-    version (GNU) {
-        return tanl(x);
-
+
+
+
+
+
-    asm
-    {
-        fld x[EBP]      ; // load theta
@@ -947 +997 @@
- *  <tr> <td> +&infin; <td> +&infin; <td> no
- *  )
- */
+version(LLVMDC)
+{
+    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 +1064 @@
-    }
-}
-
+}
+
-/** ditto */
-creal sqrt(creal z)
-{
@@ -1477 +1548 @@
-        }
-    }
-    }
-
+
+
+
+
+
+
+
+
-}
-
-debug(UnitTest) {

tango/math/internal/BignumX86.d

@@ -50 +50 @@
-private:
-version(GNU) {
-    // GDC is a filthy liar. It can't actually do inline asm.
+} else version(LLVMDC) {
+    // I guess the same goes for llvmdc to some extent :(
-} else version(D_InlineAsm_X86) {
-/* Duplicate string s, with n times, substituting index for '@'.
- *

tango/math/internal/BiguintCore.d

@@ -12 +12 @@
-} else version(GNU) {
-    // GDC lies about its X86 support
-private import tango.math.internal.BignumNoAsm;    
-
+
+
+
+
-private import tango.math.internal.BignumX86;
-} else {
-private import tango.math.internal.BignumNoAsm;

tango/stdc/stdlib.d

@@ -94 +94 @@
-{
-    void* alloca(size_t size);
-}
+else version( LLVMDC )
+{
+    pragma(alloca)
+        void* alloca(size_t size);
+}
-else version( GNU )
-{
-    private import gcc.builtins;

tango/stdc/stdarg.d

@@ -13 +13 @@
-{
-    public import std.c.stdarg;
-}
+else version( LLVMDC )
+{
+    public import llvmdc.cstdarg;
+}
-else
-{
-    alias void* va_list;