diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/import/core/atomic.di druntime/import/core/atomic.di
--- druntime-orig/import/core/atomic.di 2010-12-20 10:27:04.000000000 +0300
+++ druntime/import/core/atomic.di 2011-01-05 14:41:38.000000000 +0300
@@ -1,567 +1,664 @@
-// D import file generated from 'src\core\atomic.d'
-module core.atomic;
-version (D_InlineAsm_X86)
-{
- version = AsmX86;
- version = AsmX86_32;
- enum has64BitCAS = true;
-}
-version (D_InlineAsm_X86_64)
-{
- version = AsmX86;
- version = AsmX86_64;
- enum has64BitCAS = true;
-}
-private
-{
- template NakedType(T : shared(T))
-{
-alias T NakedType;
-}
- template NakedType(T : shared(T*))
-{
-alias T* NakedType;
-}
- template NakedType(T : const(T))
-{
-alias T NakedType;
-}
- template NakedType(T : const(T*))
-{
-alias T* NakedType;
-}
- template NamedType(T : T*)
-{
-alias T NakedType;
-}
- template NakedType(T)
-{
-alias T NakedType;
-}
-}
-version (AsmX86)
-{
- private template atomicValueIsProperlyAligned(T)
-{
-bool atomicValueIsProperlyAligned(size_t addr)
-{
-return addr % T.sizeof == 0;
-}
-}
-
-}
-version (D_Ddoc)
-{
- template atomicOp(string op,T,V1)
-{
-T atomicOp(ref shared T val, V1 mod)
-{
-return val;
-}
-}
- template cas(T,V1,V2) if (is(NakedType!(V1) == NakedType!(T)) && is(NakedType!(V2) == NakedType!(T)))
-{
-bool cas(shared(T)* here, const V1 ifThis, const V2 writeThis)
-{
-return false;
-}
-}
-}
-else
-{
- version (AsmX86_32)
-{
- template atomicOp(string op,T,V1) if (is(NakedType!(V1) == NakedType!(T)))
-{
-T atomicOp(ref shared T val, V1 mod)
-in
-{
-static if(T.sizeof > size_t.sizeof)
-{
-assert(atomicValueIsProperlyAligned!(size_t)(cast(size_t)&val));
-}
-else
-{
-assert(atomicValueIsProperlyAligned!(T)(cast(size_t)&val));
-}
-
-}
-body
-{
-static if(op == "+" || op == "-" || op == "*" || op == "/" || op == "%" || op == "^^" || op == "&" || op == "|" || op == "^" || op == "<<" || op == ">>" || op == ">>>" || op == "~" || op == "==" || op == "!=" || op == "<" || op == "<=" || op == ">" || op == ">=")
-{
-T get = val;
-mixin("return get " ~ op ~ " mod;");
-}
-else
-{
-static if(op == "+=" || op == "-=" || op == "*=" || op == "/=" || op == "%=" || op == "^^=" || op == "&=" || op == "|=" || op == "^=" || op == "<<=" || op == ">>=" || op == ">>>=")
-{
-T get,set;
-do
-{
-get = (set = atomicLoad!(msync.raw)(val));
-mixin("set " ~ op ~ " mod;");
-}
-while (!cas(&val,get,set));
-return set;
-}
-else
-{
-static assert(false,"Operation not supported.");
-}
-
-}
-
-}
-}
- template cas(T,V1,V2) if (is(NakedType!(V1) == NakedType!(T)) && is(NakedType!(V2) == NakedType!(T)))
-{
-bool cas(shared(T)* here, const V1 ifThis, const V2 writeThis)
-in
-{
-static if(T.sizeof > size_t.sizeof)
-{
-assert(atomicValueIsProperlyAligned!(size_t)(cast(size_t)here));
-}
-else
-{
-assert(atomicValueIsProperlyAligned!(T)(cast(size_t)here));
-}
-
-}
-body
-{
-static if(T.sizeof == (byte).sizeof)
-{
-asm { mov DL,writeThis; }
-asm { mov AL,ifThis; }
-asm { mov ECX,here; }
-asm { lock; }
-asm { cmpxchg[ECX],DL; }
-asm { setz AL; }
-}
-else
-{
-static if(T.sizeof == (short).sizeof)
-{
-asm { mov DX,writeThis; }
-asm { mov AX,ifThis; }
-asm { mov ECX,here; }
-asm { lock; }
-asm { cmpxchg[ECX],DX; }
-asm { setz AL; }
-}
-else
-{
-static if(T.sizeof == (int).sizeof)
-{
-asm { mov EDX,writeThis; }
-asm { mov EAX,ifThis; }
-asm { mov ECX,here; }
-asm { lock; }
-asm { cmpxchg[ECX],EDX; }
-asm { setz AL; }
-}
-else
-{
-static if(T.sizeof == (long).sizeof && has64BitCAS)
-{
-asm { push EDI; }
-asm { push EBX; }
-asm { lea EDI,writeThis; }
-asm { mov EBX,[EDI]; }
-asm { mov ECX,4[EDI]; }
-asm { lea EDI,ifThis; }
-asm { mov EAX,[EDI]; }
-asm { mov EDX,4[EDI]; }
-asm { mov EDI,here; }
-asm { lock; }
-asm { cmpxch8b[EDI]; }
-asm { setz AL; }
-asm { pop EBX; }
-asm { pop EDI; }
-}
-else
-{
-static assert(false,"Invalid template type specified.");
-}
-
-}
-
-}
-
-}
-
-}
-}
- private
-{
- template isHoistOp(msync ms)
-{
-enum bool isHoistOp = ms == msync.acq || ms == msync.seq;
-}
- template isSinkOp(msync ms)
-{
-enum bool isSinkOp = ms == msync.rel || ms == msync.seq;
-}
- template needsLoadBarrier(msync ms)
-{
-const bool needsLoadBarrier = ms != msync.raw;
-
-}
- enum msync
-{
-raw,
-acq,
-rel,
-seq,
-}
- template atomicLoad(msync ms = msync.seq,T)
-{
-T atomicLoad(ref const shared T val)
-{
-static if(T.sizeof == (byte).sizeof)
-{
-static if(needsLoadBarrier!(ms))
-{
-asm { mov DL,0; }
-asm { mov AL,0; }
-asm { mov ECX,val; }
-asm { lock; }
-asm { cmpxchg[ECX],DL; }
-}
-else
-{
-asm { mov EAX,val; }
-asm { mov AL,[EAX]; }
-}
-
-}
-else
-{
-static if(T.sizeof == (short).sizeof)
-{
-static if(needsLoadBarrier!(ms))
-{
-asm { mov DX,0; }
-asm { mov AX,0; }
-asm { mov ECX,val; }
-asm { lock; }
-asm { cmpxchg[ECX],DX; }
-}
-else
-{
-asm { mov EAX,val; }
-asm { mov AX,[EAX]; }
-}
-
-}
-else
-{
-static if(T.sizeof == (int).sizeof)
-{
-static if(needsLoadBarrier!(ms))
-{
-asm { mov EDX,0; }
-asm { mov EAX,0; }
-asm { mov ECX,val; }
-asm { lock; }
-asm { cmpxchg[ECX],EDX; }
-}
-else
-{
-asm { mov EAX,val; }
-asm { mov EAX,[EAX]; }
-}
-
-}
-else
-{
-static if(T.sizeof == (long).sizeof && has64BitCAS)
-{
-asm { push EDI; }
-asm { push EBX; }
-asm { mov EBX,0; }
-asm { mov ECX,0; }
-asm { mov EAX,0; }
-asm { mov EDX,0; }
-asm { mov EDI,val; }
-asm { lock; }
-asm { cmpxch8b[EDI]; }
-asm { pop EBX; }
-asm { pop EDI; }
-}
-else
-{
-static assert(false,"Invalid template type specified.");
-}
-
-}
-
-}
-
-}
-
-}
-}
-}
-}
-else
-{
- version (AsmX86_64)
-{
- template atomicOp(string op,T,V1) if (is(NakedType!(V1) == NakedType!(T)))
-{
-T atomicOp(ref shared T val, V1 mod)
-in
-{
-static if(T.sizeof > size_t.sizeof)
-{
-assert(atomicValueIsProperlyAligned!(size_t)(cast(size_t)&val));
-}
-else
-{
-assert(atomicValueIsProperlyAligned!(T)(cast(size_t)&val));
-}
-
-}
-body
-{
-static if(op == "+" || op == "-" || op == "*" || op == "/" || op == "%" || op == "^^" || op == "&" || op == "|" || op == "^" || op == "<<" || op == ">>" || op == ">>>" || op == "~" || op == "==" || op == "!=" || op == "<" || op == "<=" || op == ">" || op == ">=")
-{
-T get = val;
-mixin("return get " ~ op ~ " mod;");
-}
-else
-{
-static if(op == "+=" || op == "-=" || op == "*=" || op == "/=" || op == "%=" || op == "^^=" || op == "&=" || op == "|=" || op == "^=" || op == "<<=" || op == ">>=" || op == ">>>=")
-{
-T get,set;
-do
-{
-get = (set = atomicLoad!(msync.raw)(val));
-mixin("set " ~ op ~ " mod;");
-}
-while (!cas(&val,get,set));
-return set;
-}
-else
-{
-static assert(false,"Operation not supported.");
-}
-
-}
-
-}
-}
- template cas(T,V1,V2) if (is(NakedType!(V1) == NakedType!(T)) && is(NakedType!(V2) == NakedType!(T)))
-{
-bool cas(shared(T)* here, const V1 ifThis, const V2 writeThis)
-in
-{
-static if(T.sizeof > size_t.sizeof)
-{
-assert(atomicValueIsProperlyAligned!(size_t)(cast(size_t)here));
-}
-else
-{
-assert(atomicValueIsProperlyAligned!(T)(cast(size_t)here));
-}
-
-}
-body
-{
-static if(T.sizeof == (byte).sizeof)
-{
-asm { mov DL,writeThis; }
-asm { mov AL,ifThis; }
-asm { mov RCX,here; }
-asm { lock; }
-asm { cmpxchg[RCX],DL; }
-asm { setz AL; }
-}
-else
-{
-static if(T.sizeof == (short).sizeof)
-{
-asm { mov DX,writeThis; }
-asm { mov AX,ifThis; }
-asm { mov RCX,here; }
-asm { lock; }
-asm { cmpxchg[RCX],DX; }
-asm { setz AL; }
-}
-else
-{
-static if(T.sizeof == (int).sizeof)
-{
-asm { mov EDX,writeThis; }
-asm { mov EAX,ifThis; }
-asm { mov RCX,here; }
-asm { lock; }
-asm { cmpxchg[RCX],EDX; }
-asm { setz AL; }
-}
-else
-{
-static if(T.sizeof == (long).sizeof)
-{
-asm { mov RDX,writeThis; }
-asm { mov RAX,ifThis; }
-asm { mov RCX,here; }
-asm { lock; }
-asm { cmpxchg[RCX],RDX; }
-asm { setz AL; }
-}
-else
-{
-static assert(false,"Invalid template type specified.");
-}
-
-}
-
-}
-
-}
-
-}
-}
- private
-{
- template isHoistOp(msync ms)
-{
-enum bool isHoistOp = ms == msync.acq || ms == msync.seq;
-}
- template isSinkOp(msync ms)
-{
-enum bool isSinkOp = ms == msync.rel || ms == msync.seq;
-}
- template needsLoadBarrier(msync ms)
-{
-const bool needsLoadBarrier = ms != msync.raw;
-
-}
- enum msync
-{
-raw,
-acq,
-rel,
-seq,
-}
- template atomicLoad(msync ms = msync.seq,T)
-{
-T atomicLoad(ref const shared T val)
-{
-static if(T.sizeof == (byte).sizeof)
-{
-static if(needsLoadBarrier!(ms))
-{
-asm { mov DL,0; }
-asm { mov AL,0; }
-asm { mov RCX,val; }
-asm { lock; }
-asm { cmpxchg[RCX],DL; }
-}
-else
-{
-asm { mov AL,[val]; }
-}
-
-}
-else
-{
-static if(T.sizeof == (short).sizeof)
-{
-static if(needsLoadBarrier!(ms))
-{
-asm { mov DX,0; }
-asm { mov AX,0; }
-asm { mov RCX,val; }
-asm { lock; }
-asm { cmpxchg[RCX],DX; }
-}
-else
-{
-asm { mov AX,[val]; }
-}
-
-}
-else
-{
-static if(T.sizeof == (int).sizeof)
-{
-static if(needsLoadBarrier!(ms))
-{
-asm { mov EDX,0; }
-asm { mov EAX,0; }
-asm { mov RCX,val; }
-asm { lock; }
-asm { cmpxchg[RCX],EDX; }
-}
-else
-{
-asm { mov EAX,[val]; }
-}
-
-}
-else
-{
-static if(T.sizeof == (long).sizeof && has64BitCAS)
-{
-asm { push EDI; }
-asm { push EBX; }
-asm { mov EBX,0; }
-asm { mov ECX,0; }
-asm { mov EAX,0; }
-asm { mov EDX,0; }
-asm { mov RDI,val; }
-asm { lock; }
-asm { cmpxch8b[RDI]; }
-asm { pop EBX; }
-asm { pop EDI; }
-}
-else
-{
-static assert(false,"Invalid template type specified.");
-}
-
-}
-
-}
-
-}
-
-}
-}
-}
-}
-}
-}
-version (unittest)
-{
- template testCAS(msyT)
-{
-template testCAS(T)
-{
-void testCAS(T val = T.init + 1)
-{
-T base;
-shared(T) atom;
-assert(base != val);
-assert(atom == base);
-assert(cas(&atom,base,val));
-assert(atom == val);
-assert(!cas(&atom,base,base));
-assert(atom == val);
-}
-}
-}
- template testType(T)
-{
-void testType(T val = T.init + 1)
-{
-testCAS!(T)(val);
-}
-}
- }
+// D import file generated from 'druntime/src/core/atomic.d'
+module core.atomic;
+version (D_InlineAsm_X86)
+{
+ version = AsmX86;
+ version = AsmX86_32;
+ enum has64BitCAS = true;
+}
+version (D_InlineAsm_X86_64)
+{
+ version = AsmX86;
+ version = AsmX86_64;
+ enum has64BitCAS = true;
+}
+private
+{
+ template NakedType(T : shared(T))
+{
+alias T NakedType;
+}
+ template NakedType(T : shared(T*))
+{
+alias T* NakedType;
+}
+ template NakedType(T : const(T))
+{
+alias T NakedType;
+}
+ template NakedType(T : const(T*))
+{
+alias T* NakedType;
+}
+ template NamedType(T : T*)
+{
+alias T NakedType;
+}
+ template NakedType(T)
+{
+alias T NakedType;
+}
+}
+version (AsmX86)
+{
+ private template atomicValueIsProperlyAligned(T)
+{
+bool atomicValueIsProperlyAligned(size_t addr)
+{
+return addr % T.sizeof == 0;
+}
+}
+
+}
+version (D_Ddoc)
+{
+ template atomicOp(string op,T,V1)
+{
+T atomicOp(ref shared T val, V1 mod)
+{
+return val;
+}
+}
+ template cas(T,V1,V2) if (is(NakedType!(V1) == NakedType!(T)) && is(NakedType!(V2) == NakedType!(T)))
+{
+bool cas(shared(T)* here, const V1 ifThis, const V2 writeThis)
+{
+return false;
+}
+}
+}
+else
+{
+ version (LDC)
+{
+ import ldc.intrinsics;
+ template atomicOp(string op,T,V1) if (is(NakedType!(V1) == NakedType!(T)))
+{
+T atomicOp(ref shared T val, V1 mod)
+{
+static if(op == "+" || op == "-" || op == "*" || op == "/" || op == "%" || op == "^^" || op == "&" || op == "|" || op == "^" || op == "<<" || op == ">>" || op == ">>>" || op == "~" || op == "==" || op == "!=" || op == "<" || op == "<=" || op == ">" || op == ">=")
+{
+T get = val;
+mixin("return get " ~ op ~ " mod;");
+}
+else
+{
+static if(op == "+=" || op == "-=" || op == "*=" || op == "/=" || op == "%=" || op == "^^=" || op == "&=" || op == "|=" || op == "^=" || op == "<<=" || op == ">>=" || op == ">>>=")
+{
+T get,set;
+do
+{
+get = (set = atomicLoad!(msync.raw)(val));
+mixin("set " ~ op ~ " mod;");
+}
+while (!cas(&val,get,set));
+return set;
+}
+else
+{
+static assert(false,"Operation not supported.");
+}
+
+}
+
+}
+}
+ template cas(T,V1,V2) if (is(NakedType!(V1) == NakedType!(T)) && is(NakedType!(V2) == NakedType!(T)))
+{
+bool cas(shared(T)* here, const V1 ifThis, const V2 writeThis)
+{
+T oldval = void;
+static if(is(T P == U*,U))
+{
+oldval = cast(T)llvm_atomic_cmp_swap!(size_t)(cast(shared(size_t*))&writeThis,cast(size_t)ifThis,cast(size_t)here);
+}
+else
+{
+static if(is(T == bool))
+{
+oldval = llvm_atomic_cmp_swap!(ubyte)(cast(shared(ubyte*))&writeThis,ifThis ? 1 : 0,here ? 1 : 0) ? 0 : 1;
+}
+else
+{
+oldval = llvm_atomic_cmp_swap!(T)(here,ifThis,writeThis);
+}
+
+}
+
+return oldval == ifThis;
+}
+}
+ private
+{
+ enum msync
+{
+raw,
+acq,
+rel,
+seq,
+}
+ template atomicLoad(msync ms = msync.seq,T)
+{
+T atomicLoad(ref const shared T val)
+{
+llvm_memory_barrier(ms == msync.acq || ms == msync.seq,ms == msync.acq || ms == msync.seq,ms == msync.rel || ms == msync.seq,ms == msync.rel || ms == msync.seq,false);
+static if(is(T P == U*,U))
+{
+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);
+}
+
+}
+
+}
+}
+}
+}
+else
+{
+ version (AsmX86_32)
+{
+ template atomicOp(string op,T,V1) if (is(NakedType!(V1) == NakedType!(T)))
+{
+T atomicOp(ref shared T val, V1 mod)
+in
+{
+static if(T.sizeof > size_t.sizeof)
+{
+assert(atomicValueIsProperlyAligned!(size_t)(cast(size_t)&val));
+}
+else
+{
+assert(atomicValueIsProperlyAligned!(T)(cast(size_t)&val));
+}
+
+}
+body
+{
+static if(op == "+" || op == "-" || op == "*" || op == "/" || op == "%" || op == "^^" || op == "&" || op == "|" || op == "^" || op == "<<" || op == ">>" || op == ">>>" || op == "~" || op == "==" || op == "!=" || op == "<" || op == "<=" || op == ">" || op == ">=")
+{
+T get = val;
+mixin("return get " ~ op ~ " mod;");
+}
+else
+{
+static if(op == "+=" || op == "-=" || op == "*=" || op == "/=" || op == "%=" || op == "^^=" || op == "&=" || op == "|=" || op == "^=" || op == "<<=" || op == ">>=" || op == ">>>=")
+{
+T get,set;
+do
+{
+get = (set = atomicLoad!(msync.raw)(val));
+mixin("set " ~ op ~ " mod;");
+}
+while (!cas(&val,get,set));
+return set;
+}
+else
+{
+static assert(false,"Operation not supported.");
+}
+
+}
+
+}
+}
+ template cas(T,V1,V2) if (is(NakedType!(V1) == NakedType!(T)) && is(NakedType!(V2) == NakedType!(T)))
+{
+bool cas(shared(T)* here, const V1 ifThis, const V2 writeThis)
+in
+{
+static if(T.sizeof > size_t.sizeof)
+{
+assert(atomicValueIsProperlyAligned!(size_t)(cast(size_t)here));
+}
+else
+{
+assert(atomicValueIsProperlyAligned!(T)(cast(size_t)here));
+}
+
+}
+body
+{
+static if(T.sizeof == (byte).sizeof)
+{
+asm { mov DL,writeThis; }
+asm { mov AL,ifThis; }
+asm { mov ECX,here; }
+asm { lock; }
+asm { cmpxchg[ECX],DL; }
+asm { setz AL; }
+}
+else
+{
+static if(T.sizeof == (short).sizeof)
+{
+asm { mov DX,writeThis; }
+asm { mov AX,ifThis; }
+asm { mov ECX,here; }
+asm { lock; }
+asm { cmpxchg[ECX],DX; }
+asm { setz AL; }
+}
+else
+{
+static if(T.sizeof == (int).sizeof)
+{
+asm { mov EDX,writeThis; }
+asm { mov EAX,ifThis; }
+asm { mov ECX,here; }
+asm { lock; }
+asm { cmpxchg[ECX],EDX; }
+asm { setz AL; }
+}
+else
+{
+static if(T.sizeof == (long).sizeof && has64BitCAS)
+{
+asm { push EDI; }
+asm { push EBX; }
+asm { lea EDI,writeThis; }
+asm { mov EBX,[EDI]; }
+asm { mov ECX,4[EDI]; }
+asm { lea EDI,ifThis; }
+asm { mov EAX,[EDI]; }
+asm { mov EDX,4[EDI]; }
+asm { mov EDI,here; }
+asm { lock; }
+asm { cmpxch8b[EDI]; }
+asm { setz AL; }
+asm { pop EBX; }
+asm { pop EDI; }
+}
+else
+{
+static assert(false,"Invalid template type specified.");
+}
+
+}
+
+}
+
+}
+
+}
+}
+ private
+{
+ template isHoistOp(msync ms)
+{
+enum bool isHoistOp = ms == msync.acq || ms == msync.seq;
+}
+ template isSinkOp(msync ms)
+{
+enum bool isSinkOp = ms == msync.rel || ms == msync.seq;
+}
+ template needsLoadBarrier(msync ms)
+{
+const bool needsLoadBarrier = ms != msync.raw;
+
+}
+ enum msync
+{
+raw,
+acq,
+rel,
+seq,
+}
+ template atomicLoad(msync ms = msync.seq,T)
+{
+T atomicLoad(ref const shared T val)
+{
+static if(T.sizeof == (byte).sizeof)
+{
+static if(needsLoadBarrier!(ms))
+{
+asm { mov DL,0; }
+asm { mov AL,0; }
+asm { mov ECX,val; }
+asm { lock; }
+asm { cmpxchg[ECX],DL; }
+}
+else
+{
+asm { mov EAX,val; }
+asm { mov AL,[EAX]; }
+}
+
+}
+else
+{
+static if(T.sizeof == (short).sizeof)
+{
+static if(needsLoadBarrier!(ms))
+{
+asm { mov DX,0; }
+asm { mov AX,0; }
+asm { mov ECX,val; }
+asm { lock; }
+asm { cmpxchg[ECX],DX; }
+}
+else
+{
+asm { mov EAX,val; }
+asm { mov AX,[EAX]; }
+}
+
+}
+else
+{
+static if(T.sizeof == (int).sizeof)
+{
+static if(needsLoadBarrier!(ms))
+{
+asm { mov EDX,0; }
+asm { mov EAX,0; }
+asm { mov ECX,val; }
+asm { lock; }
+asm { cmpxchg[ECX],EDX; }
+}
+else
+{
+asm { mov EAX,val; }
+asm { mov EAX,[EAX]; }
+}
+
+}
+else
+{
+static if(T.sizeof == (long).sizeof && has64BitCAS)
+{
+asm { push EDI; }
+asm { push EBX; }
+asm { mov EBX,0; }
+asm { mov ECX,0; }
+asm { mov EAX,0; }
+asm { mov EDX,0; }
+asm { mov EDI,val; }
+asm { lock; }
+asm { cmpxch8b[EDI]; }
+asm { pop EBX; }
+asm { pop EDI; }
+}
+else
+{
+static assert(false,"Invalid template type specified.");
+}
+
+}
+
+}
+
+}
+
+}
+}
+}
+}
+else
+{
+ version (AsmX86_64)
+{
+ template atomicOp(string op,T,V1) if (is(NakedType!(V1) == NakedType!(T)))
+{
+T atomicOp(ref shared T val, V1 mod)
+in
+{
+static if(T.sizeof > size_t.sizeof)
+{
+assert(atomicValueIsProperlyAligned!(size_t)(cast(size_t)&val));
+}
+else
+{
+assert(atomicValueIsProperlyAligned!(T)(cast(size_t)&val));
+}
+
+}
+body
+{
+static if(op == "+" || op == "-" || op == "*" || op == "/" || op == "%" || op == "^^" || op == "&" || op == "|" || op == "^" || op == "<<" || op == ">>" || op == ">>>" || op == "~" || op == "==" || op == "!=" || op == "<" || op == "<=" || op == ">" || op == ">=")
+{
+T get = val;
+mixin("return get " ~ op ~ " mod;");
+}
+else
+{
+static if(op == "+=" || op == "-=" || op == "*=" || op == "/=" || op == "%=" || op == "^^=" || op == "&=" || op == "|=" || op == "^=" || op == "<<=" || op == ">>=" || op == ">>>=")
+{
+T get,set;
+do
+{
+get = (set = atomicLoad!(msync.raw)(val));
+mixin("set " ~ op ~ " mod;");
+}
+while (!cas(&val,get,set));
+return set;
+}
+else
+{
+static assert(false,"Operation not supported.");
+}
+
+}
+
+}
+}
+ template cas(T,V1,V2) if (is(NakedType!(V1) == NakedType!(T)) && is(NakedType!(V2) == NakedType!(T)))
+{
+bool cas(shared(T)* here, const V1 ifThis, const V2 writeThis)
+in
+{
+static if(T.sizeof > size_t.sizeof)
+{
+assert(atomicValueIsProperlyAligned!(size_t)(cast(size_t)here));
+}
+else
+{
+assert(atomicValueIsProperlyAligned!(T)(cast(size_t)here));
+}
+
+}
+body
+{
+static if(T.sizeof == (byte).sizeof)
+{
+asm { mov DL,writeThis; }
+asm { mov AL,ifThis; }
+asm { mov RCX,here; }
+asm { lock; }
+asm { cmpxchg[RCX],DL; }
+asm { setz AL; }
+}
+else
+{
+static if(T.sizeof == (short).sizeof)
+{
+asm { mov DX,writeThis; }
+asm { mov AX,ifThis; }
+asm { mov RCX,here; }
+asm { lock; }
+asm { cmpxchg[RCX],DX; }
+asm { setz AL; }
+}
+else
+{
+static if(T.sizeof == (int).sizeof)
+{
+asm { mov EDX,writeThis; }
+asm { mov EAX,ifThis; }
+asm { mov RCX,here; }
+asm { lock; }
+asm { cmpxchg[RCX],EDX; }
+asm { setz AL; }
+}
+else
+{
+static if(T.sizeof == (long).sizeof)
+{
+asm { mov RDX,writeThis; }
+asm { mov RAX,ifThis; }
+asm { mov RCX,here; }
+asm { lock; }
+asm { cmpxchg[RCX],RDX; }
+asm { setz AL; }
+}
+else
+{
+static assert(false,"Invalid template type specified.");
+}
+
+}
+
+}
+
+}
+
+}
+}
+ private
+{
+ template isHoistOp(msync ms)
+{
+enum bool isHoistOp = ms == msync.acq || ms == msync.seq;
+}
+ template isSinkOp(msync ms)
+{
+enum bool isSinkOp = ms == msync.rel || ms == msync.seq;
+}
+ template needsLoadBarrier(msync ms)
+{
+const bool needsLoadBarrier = ms != msync.raw;
+
+}
+ enum msync
+{
+raw,
+acq,
+rel,
+seq,
+}
+ template atomicLoad(msync ms = msync.seq,T)
+{
+T atomicLoad(ref const shared T val)
+{
+static if(T.sizeof == (byte).sizeof)
+{
+static if(needsLoadBarrier!(ms))
+{
+asm { mov DL,0; }
+asm { mov AL,0; }
+asm { mov RCX,val; }
+asm { lock; }
+asm { cmpxchg[RCX],DL; }
+}
+else
+{
+asm { mov AL,[val]; }
+}
+
+}
+else
+{
+static if(T.sizeof == (short).sizeof)
+{
+static if(needsLoadBarrier!(ms))
+{
+asm { mov DX,0; }
+asm { mov AX,0; }
+asm { mov RCX,val; }
+asm { lock; }
+asm { cmpxchg[RCX],DX; }
+}
+else
+{
+asm { mov AX,[val]; }
+}
+
+}
+else
+{
+static if(T.sizeof == (int).sizeof)
+{
+static if(needsLoadBarrier!(ms))
+{
+asm { mov EDX,0; }
+asm { mov EAX,0; }
+asm { mov RCX,val; }
+asm { lock; }
+asm { cmpxchg[RCX],EDX; }
+}
+else
+{
+asm { mov EAX,[val]; }
+}
+
+}
+else
+{
+static if(T.sizeof == (long).sizeof && has64BitCAS)
+{
+asm { push EDI; }
+asm { push EBX; }
+asm { mov EBX,0; }
+asm { mov ECX,0; }
+asm { mov EAX,0; }
+asm { mov EDX,0; }
+asm { mov RDI,val; }
+asm { lock; }
+asm { cmpxch8b[RDI]; }
+asm { pop EBX; }
+asm { pop EDI; }
+}
+else
+{
+static assert(false,"Invalid template type specified.");
+}
+
+}
+
+}
+
+}
+
+}
+}
+}
+}
+}
+}
+}
+version (unittest)
+{
+ template testCAS(msyT)
+{
+template testCAS(T)
+{
+void testCAS(T val = T.init + 1)
+{
+T base;
+shared(T) atom;
+assert(base != val);
+assert(atom == base);
+assert(cas(&atom,base,val));
+assert(atom == val);
+assert(!cas(&atom,base,base));
+assert(atom == val);
+}
+}
+}
+ template testType(T)
+{
+void testType(T val = T.init + 1)
+{
+testCAS!(T)(val);
+}
+}
+ }
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/import/core/stdc/math.di druntime/import/core/stdc/math.di
--- druntime-orig/import/core/stdc/math.di 2010-12-20 10:27:04.000000000 +0300
+++ druntime/import/core/stdc/math.di 2011-01-05 14:40:22.000000000 +0300
@@ -1,1134 +1,1135 @@
-// D import file generated from 'src\core\stdc\math.d'
-module core.stdc.math;
-private import core.stdc.config;
-
-extern (C) nothrow
-{
- alias float float_t;
- alias double double_t;
- enum double HUGE_VAL = (double).infinity;
- enum double HUGE_VALF = (float).infinity;
- enum double HUGE_VALL = (real).infinity;
- enum float INFINITY = (float).infinity;
- enum float NAN = (float).nan;
- enum int FP_ILOGB0 = (int).min;
- enum int FP_ILOGBNAN = (int).min;
- enum int MATH_ERRNO = 1;
- enum int MATH_ERREXCEPT = 2;
- enum int math_errhandling = MATH_ERRNO | MATH_ERREXCEPT;
- version (none)
-{
- int fpclassify(float x);
- int fpclassify(double x);
- int fpclassify(real x);
- int isfinite(float x);
- int isfinite(double x);
- int isfinite(real x);
- int isinf(float x);
- int isinf(double x);
- int isinf(real x);
- int isnan(float x);
- int isnan(double x);
- int isnan(real x);
- int isnormal(float x);
- int isnormal(double x);
- int isnormal(real x);
- int signbit(float x);
- int signbit(double x);
- int signbit(real x);
- int isgreater(float x, float y);
- int isgreater(double x, double y);
- int isgreater(real x, real y);
- int isgreaterequal(float x, float y);
- int isgreaterequal(double x, double y);
- int isgreaterequal(real x, real y);
- int isless(float x, float y);
- int isless(double x, double y);
- int isless(real x, real y);
- int islessequal(float x, float y);
- int islessequal(double x, double y);
- int islessequal(real x, real y);
- int islessgreater(float x, float y);
- int islessgreater(double x, double y);
- int islessgreater(real x, real y);
- int isunordered(float x, float y);
- int isunordered(double x, double y);
- int isunordered(real x, real y);
-}
- version (DigitalMars)
-{
- version (Windows)
-{
- version = DigitalMarsWin32;
-}
-}
- version (DigitalMarsWin32)
-{
- enum
-{
-FP_NANS = 0,
-FP_NANQ = 1,
-FP_INFINITE = 2,
-FP_NORMAL = 3,
-FP_SUBNORMAL = 4,
-FP_ZERO = 5,
-FP_NAN = FP_NANQ,
-FP_EMPTY = 6,
-FP_UNSUPPORTED = 7,
-}
- enum
-{
-FP_FAST_FMA = 0,
-FP_FAST_FMAF = 0,
-FP_FAST_FMAL = 0,
-}
- uint __fpclassify_f(float x);
- uint __fpclassify_d(double x);
- uint __fpclassify_ld(real x);
- extern (D)
-{
- int fpclassify(float x)
-{
-return __fpclassify_f(x);
-}
- int fpclassify(double x)
-{
-return __fpclassify_d(x);
-}
- int fpclassify(real x)
-{
-return (real).sizeof == (double).sizeof ? __fpclassify_d(x) : __fpclassify_ld(x);
-}
- int isfinite(float x)
-{
-return fpclassify(x) >= FP_NORMAL;
-}
- int isfinite(double x)
-{
-return fpclassify(x) >= FP_NORMAL;
-}
- int isfinite(real x)
-{
-return fpclassify(x) >= FP_NORMAL;
-}
- int isinf(float x)
-{
-return fpclassify(x) == FP_INFINITE;
-}
- int isinf(double x)
-{
-return fpclassify(x) == FP_INFINITE;
-}
- int isinf(real x)
-{
-return fpclassify(x) == FP_INFINITE;
-}
- int isnan(float x)
-{
-return fpclassify(x) <= FP_NANQ;
-}
- int isnan(double x)
-{
-return fpclassify(x) <= FP_NANQ;
-}
- int isnan(real x)
-{
-return fpclassify(x) <= FP_NANQ;
-}
- int isnormal(float x)
-{
-return fpclassify(x) == FP_NORMAL;
-}
- int isnormal(double x)
-{
-return fpclassify(x) == FP_NORMAL;
-}
- int isnormal(real x)
-{
-return fpclassify(x) == FP_NORMAL;
-}
- int signbit(float x)
-{
-return (cast(short*)&x)[1] & 32768;
-}
- int signbit(double x)
-{
-return (cast(short*)&x)[3] & 32768;
-}
- int signbit(real x)
-{
-return (real).sizeof == (double).sizeof ? (cast(short*)&x)[3] & 32768 : (cast(short*)&x)[4] & 32768;
-}
-}
-}
-else
-{
- version (linux)
-{
- enum
-{
-FP_NAN,
-FP_INFINITE,
-FP_ZERO,
-FP_SUBNORMAL,
-FP_NORMAL,
-}
- enum
-{
-FP_FAST_FMA = 0,
-FP_FAST_FMAF = 0,
-FP_FAST_FMAL = 0,
-}
- int __fpclassifyf(float x);
- int __fpclassify(double x);
- int __fpclassifyl(real x);
- int __finitef(float x);
- int __finite(double x);
- int __finitel(real x);
- int __isinff(float x);
- int __isinf(double x);
- int __isinfl(real x);
- int __isnanf(float x);
- int __isnan(double x);
- int __isnanl(real x);
- int __signbitf(float x);
- int __signbit(double x);
- int __signbitl(real x);
- extern (D)
-{
- int fpclassify(float x)
-{
-return __fpclassifyf(x);
-}
- int fpclassify(double x)
-{
-return __fpclassify(x);
-}
- int fpclassify(real x)
-{
-return (real).sizeof == (double).sizeof ? __fpclassify(x) : __fpclassifyl(x);
-}
- int isfinite(float x)
-{
-return __finitef(x);
-}
- int isfinite(double x)
-{
-return __finite(x);
-}
- int isfinite(real x)
-{
-return (real).sizeof == (double).sizeof ? __finite(x) : __finitel(x);
-}
- int isinf(float x)
-{
-return __isinff(x);
-}
- int isinf(double x)
-{
-return __isinf(x);
-}
- int isinf(real x)
-{
-return (real).sizeof == (double).sizeof ? __isinf(x) : __isinfl(x);
-}
- int isnan(float x)
-{
-return __isnanf(x);
-}
- int isnan(double x)
-{
-return __isnan(x);
-}
- int isnan(real x)
-{
-return (real).sizeof == (double).sizeof ? __isnan(x) : __isnanl(x);
-}
- int isnormal(float x)
-{
-return fpclassify(x) == FP_NORMAL;
-}
- int isnormal(double x)
-{
-return fpclassify(x) == FP_NORMAL;
-}
- int isnormal(real x)
-{
-return fpclassify(x) == FP_NORMAL;
-}
- int signbit(float x)
-{
-return __signbitf(x);
-}
- int signbit(double x)
-{
-return __signbit(x);
-}
- int signbit(real x)
-{
-return (real).sizeof == (double).sizeof ? __signbit(x) : __signbitl(x);
-}
-}
-}
-else
-{
- version (OSX)
-{
- enum
-{
-FP_NAN = 1,
-FP_INFINITE = 2,
-FP_ZERO = 3,
-FP_NORMAL = 4,
-FP_SUBNORMAL = 5,
-FP_SUPERNORMAL = 6,
-}
- enum
-{
-FP_FAST_FMA = 0,
-FP_FAST_FMAF = 0,
-FP_FAST_FMAL = 0,
-}
- int __fpclassifyf(float x);
- int __fpclassifyd(double x);
- int __fpclassify(real x);
- int __isfinitef(float x);
- int __isfinited(double x);
- int __isfinite(real x);
- int __isinff(float x);
- int __isinfd(double x);
- int __isinf(real x);
- int __isnanf(float x);
- int __isnand(double x);
- int __isnan(real x);
- int __signbitf(float x);
- int __signbitd(double x);
- int __signbitl(real x);
- extern (D)
-{
- int fpclassify(float x)
-{
-return __fpclassifyf(x);
-}
- int fpclassify(double x)
-{
-return __fpclassifyd(x);
-}
- int fpclassify(real x)
-{
-return (real).sizeof == (double).sizeof ? __fpclassifyd(x) : __fpclassify(x);
-}
- int isfinite(float x)
-{
-return __isfinitef(x);
-}
- int isfinite(double x)
-{
-return __isfinited(x);
-}
- int isfinite(real x)
-{
-return (real).sizeof == (double).sizeof ? __isfinited(x) : __isfinite(x);
-}
- int isinf(float x)
-{
-return __isinff(x);
-}
- int isinf(double x)
-{
-return __isinfd(x);
-}
- int isinf(real x)
-{
-return (real).sizeof == (double).sizeof ? __isinfd(x) : __isinf(x);
-}
- int isnan(float x)
-{
-return __isnanf(x);
-}
- int isnan(double x)
-{
-return __isnand(x);
-}
- int isnan(real x)
-{
-return (real).sizeof == (double).sizeof ? __isnand(x) : __isnan(x);
-}
- int isnormal(float x)
-{
-return fpclassify(x) == FP_NORMAL;
-}
- int isnormal(double x)
-{
-return fpclassify(x) == FP_NORMAL;
-}
- int isnormal(real x)
-{
-return fpclassify(x) == FP_NORMAL;
-}
- int signbit(float x)
-{
-return __signbitf(x);
-}
- int signbit(double x)
-{
-return __signbitd(x);
-}
- int signbit(real x)
-{
-return (real).sizeof == (double).sizeof ? __signbitd(x) : __signbitl(x);
-}
-}
-}
-else
-{
- version (FreeBSD)
-{
- enum
-{
-FP_INFINITE = 1,
-FP_NAN = 2,
-FP_NORMAL = 4,
-FP_SUBNORMAL = 8,
-FP_ZERO = 16,
-}
- enum
-{
-FP_FAST_FMA = 0,
-FP_FAST_FMAF = 0,
-FP_FAST_FMAL = 0,
-}
- int __fpclassifyd(double);
- int __fpclassifyf(float);
- int __fpclassifyl(real);
- int __isfinitef(float);
- int __isfinite(double);
- int __isfinitel(real);
- int __isinff(float);
- int __isinfl(real);
- int __isnanl(real);
- int __isnormalf(float);
- int __isnormal(double);
- int __isnormall(real);
- int __signbit(double);
- int __signbitf(float);
- int __signbitl(real);
- extern (D)
-{
- int fpclassify(float x)
-{
-return __fpclassifyf(x);
-}
- int fpclassify(double x)
-{
-return __fpclassifyd(x);
-}
- int fpclassify(real x)
-{
-return __fpclassifyl(x);
-}
- int isfinite(float x)
-{
-return __isfinitef(x);
-}
- int isfinite(double x)
-{
-return __isfinite(x);
-}
- int isfinite(real x)
-{
-return __isfinitel(x);
-}
- int isinf(float x)
-{
-return __isinff(x);
-}
- int isinf(double x)
-{
-return __isinfl(x);
-}
- int isinf(real x)
-{
-return __isinfl(x);
-}
- int isnan(float x)
-{
-return __isnanl(x);
-}
- int isnan(double x)
-{
-return __isnanl(x);
-}
- int isnan(real x)
-{
-return __isnanl(x);
-}
- int isnormal(float x)
-{
-return __isnormalf(x);
-}
- int isnormal(double x)
-{
-return __isnormal(x);
-}
- int isnormal(real x)
-{
-return __isnormall(x);
-}
- int signbit(float x)
-{
-return __signbitf(x);
-}
- int signbit(double x)
-{
-return __signbit(x);
-}
- int signbit(real x)
-{
-return __signbit(x);
-}
-}
-}
-}
-}
-}
- extern (D)
-{
- int isgreater(float x, float y)
-{
-return !(x !> y);
-}
- int isgreater(double x, double y)
-{
-return !(x !> y);
-}
- int isgreater(real x, real y)
-{
-return !(x !> y);
-}
- int isgreaterequal(float x, float y)
-{
-return !(x !>= y);
-}
- int isgreaterequal(double x, double y)
-{
-return !(x !>= y);
-}
- int isgreaterequal(real x, real y)
-{
-return !(x !>= y);
-}
- int isless(float x, float y)
-{
-return !(x !< y);
-}
- int isless(double x, double y)
-{
-return !(x !< y);
-}
- int isless(real x, real y)
-{
-return !(x !< y);
-}
- int islessequal(float x, float y)
-{
-return !(x !<= y);
-}
- int islessequal(double x, double y)
-{
-return !(x !<= y);
-}
- int islessequal(real x, real y)
-{
-return !(x !<= y);
-}
- int islessgreater(float x, float y)
-{
-return !(x !<> y);
-}
- int islessgreater(double x, double y)
-{
-return !(x !<> y);
-}
- int islessgreater(real x, real y)
-{
-return !(x !<> y);
-}
- int isunordered(float x, float y)
-{
-return x !<>= y;
-}
- int isunordered(double x, double y)
-{
-return x !<>= y;
-}
- int isunordered(real x, real y)
-{
-return x !<>= y;
-}
-}
- version (FreeBSD)
-{
- version (all)
-{
- real acosl(real x)
-{
-return acos(x);
-}
- real asinl(real x)
-{
-return asin(x);
-}
- real atanl(real x)
-{
-return atan(x);
-}
- real atan2l(real y, real x)
-{
-return atan2(y,x);
-}
- real cosl(real x)
-{
-return cos(x);
-}
- real sinl(real x)
-{
-return sin(x);
-}
- real tanl(real x)
-{
-return tan(x);
-}
- real exp2l(real x)
-{
-return exp2(x);
-}
- real frexpl(real value, int* exp)
-{
-return frexp(value,exp);
-}
- int ilogbl(real x)
-{
-return ilogb(x);
-}
- real ldexpl(real x, int exp)
-{
-return ldexp(x,exp);
-}
- real logbl(real x)
-{
-return logb(x);
-}
- real scalbnl(real x, int n)
-{
-return scalbn(x,n);
-}
- real scalblnl(real x, c_long n)
-{
-return scalbln(x,n);
-}
- real fabsl(real x)
-{
-return fabs(x);
-}
- real hypotl(real x, real y)
-{
-return hypot(x,y);
-}
- real sqrtl(real x)
-{
-return sqrt(x);
-}
- real ceill(real x)
-{
-return ceil(x);
-}
- real floorl(real x)
-{
-return floor(x);
-}
- real nearbyintl(real x)
-{
-return nearbyint(x);
-}
- real rintl(real x)
-{
-return rint(x);
-}
- c_long lrintl(real x)
-{
-return lrint(x);
-}
- real roundl(real x)
-{
-return round(x);
-}
- c_long lroundl(real x)
-{
-return lround(x);
-}
- long llroundl(real x)
-{
-return llround(x);
-}
- real truncl(real x)
-{
-return trunc(x);
-}
- real fmodl(real x, real y)
-{
-return fmod(x,y);
-}
- real remainderl(real x, real y)
-{
-return remainder(x,y);
-}
- real remquol(real x, real y, int* quo)
-{
-return remquo(x,y,quo);
-}
- real copysignl(real x, real y)
-{
-return copysign(x,y);
-}
- real nextafterl(real x, real y)
-{
-return nextafter(x,y);
-}
- real nexttowardl(real x, real y)
-{
-return nexttoward(x,y);
-}
- real fdiml(real x, real y)
-{
-return fdim(x,y);
-}
- real fmaxl(real x, real y)
-{
-return fmax(x,y);
-}
- real fminl(real x, real y)
-{
-return fmin(x,y);
-}
- real fmal(real x, real y, real z)
-{
-return fma(x,y,z);
-}
-}
-else
-{
- real acosl(real x);
- real asinl(real x);
- real atanl(real x);
- real atan2l(real y, real x);
- real cosl(real x);
- real sinl(real x);
- real tanl(real x);
- real exp2l(real x);
- real frexpl(real value, int* exp);
- int ilogbl(real x);
- real ldexpl(real x, int exp);
- real logbl(real x);
- real modfl(real value, real* iptr);
- real scalbnl(real x, int n);
- real scalblnl(real x, c_long n);
- real fabsl(real x);
- real hypotl(real x, real y);
- real sqrtl(real x);
- real ceill(real x);
- real floorl(real x);
- real nearbyintl(real x);
- real rintl(real x);
- c_long lrintl(real x);
- real roundl(real x);
- c_long lroundl(real x);
- long llroundl(real x);
- real truncl(real x);
- real fmodl(real x, real y);
- real remainderl(real x, real y);
- real remquol(real x, real y, int* quo);
- real copysignl(real x, real y);
- double nan(char* tagp);
- float nanf(char* tagp);
- real nanl(char* tagp);
- real nextafterl(real x, real y);
- real nexttowardl(real x, real y);
- real fdiml(real x, real y);
- real fmaxl(real x, real y);
- real fminl(real x, real y);
- real fmal(real x, real y, real z);
-}
- double acos(double x);
- float acosf(float x);
- double asin(double x);
- float asinf(float x);
- double atan(double x);
- float atanf(float x);
- double atan2(double y, double x);
- float atan2f(float y, float x);
- double cos(double x);
- float cosf(float x);
- double sin(double x);
- float sinf(float x);
- double tan(double x);
- float tanf(float x);
- double acosh(double x);
- float acoshf(float x);
- real acoshl(real x)
-{
-return acosh(x);
-}
- double asinh(double x);
- float asinhf(float x);
- real asinhl(real x)
-{
-return asinh(x);
-}
- double atanh(double x);
- float atanhf(float x);
- real atanhl(real x)
-{
-return atanh(x);
-}
- double cosh(double x);
- float coshf(float x);
- real coshl(real x)
-{
-return cosh(x);
-}
- double sinh(double x);
- float sinhf(float x);
- real sinhl(real x)
-{
-return sinh(x);
-}
- double tanh(double x);
- float tanhf(float x);
- real tanhl(real x)
-{
-return tanh(x);
-}
- double exp(double x);
- float expf(float x);
- real expl(real x)
-{
-return exp(x);
-}
- double exp2(double x);
- float exp2f(float x);
- double expm1(double x);
- float expm1f(float x);
- real expm1l(real x)
-{
-return expm1(x);
-}
- double frexp(double value, int* exp);
- float frexpf(float value, int* exp);
- int ilogb(double x);
- int ilogbf(float x);
- double ldexp(double x, int exp);
- float ldexpf(float x, int exp);
- double log(double x);
- float logf(float x);
- real logl(real x)
-{
-return log(x);
-}
- double log10(double x);
- float log10f(float x);
- real log10l(real x)
-{
-return log10(x);
-}
- double log1p(double x);
- float log1pf(float x);
- real log1pl(real x)
-{
-return log1p(x);
-}
- private enum real ONE_LN2 = 1 / 0x1.62e42fefa39ef358p-1L;
-
- double log2(double x)
-{
-return log(x) * ONE_LN2;
-}
- float log2f(float x)
-{
-return logf(x) * ONE_LN2;
-}
- real log2l(real x)
-{
-return logl(x) * ONE_LN2;
-}
- double logb(double x);
- float logbf(float x);
- double modf(double value, double* iptr);
- float modff(float value, float* iptr);
- double scalbn(double x, int n);
- float scalbnf(float x, int n);
- double scalbln(double x, c_long n);
- float scalblnf(float x, c_long n);
- double cbrt(double x);
- float cbrtf(float x);
- real cbrtl(real x)
-{
-return cbrt(x);
-}
- double fabs(double x);
- float fabsf(float x);
- double hypot(double x, double y);
- float hypotf(float x, float y);
- double pow(double x, double y);
- float powf(float x, float y);
- real powl(real x, real y)
-{
-return pow(x,y);
-}
- double sqrt(double x);
- float sqrtf(float x);
- double erf(double x);
- float erff(float x);
- real erfl(real x)
-{
-return erf(x);
-}
- double erfc(double x);
- float erfcf(float x);
- real erfcl(real x)
-{
-return erfc(x);
-}
- double lgamma(double x);
- float lgammaf(float x);
- real lgammal(real x)
-{
-return lgamma(x);
-}
- double tgamma(double x);
- float tgammaf(float x);
- real tgammal(real x)
-{
-return tgamma(x);
-}
- double ceil(double x);
- float ceilf(float x);
- double floor(double x);
- float floorf(float x);
- double nearbyint(double x);
- float nearbyintf(float x);
- double rint(double x);
- float rintf(float x);
- c_long lrint(double x);
- c_long lrintf(float x);
- long llrint(double x);
- long llrintf(float x);
- long llrintl(real x)
-{
-return llrint(x);
-}
- double round(double x);
- float roundf(float x);
- c_long lround(double x);
- c_long lroundf(float x);
- long llround(double x);
- long llroundf(float x);
- double trunc(double x);
- float truncf(float x);
- double fmod(double x, double y);
- float fmodf(float x, float y);
- double remainder(double x, double y);
- float remainderf(float x, float y);
- double remquo(double x, double y, int* quo);
- float remquof(float x, float y, int* quo);
- double copysign(double x, double y);
- float copysignf(float x, float y);
- double nextafter(double x, double y);
- float nextafterf(float x, float y);
- double nexttoward(double x, real y);
- float nexttowardf(float x, real y);
- double fdim(double x, double y);
- float fdimf(float x, float y);
- double fmax(double x, double y);
- float fmaxf(float x, float y);
- double fmin(double x, double y);
- float fminf(float x, float y);
- double fma(double x, double y, double z);
- float fmaf(float x, float y, float z);
-}
-else
-{
- double acos(double x);
- float acosf(float x);
- real acosl(real x);
- double asin(double x);
- float asinf(float x);
- real asinl(real x);
- double atan(double x);
- float atanf(float x);
- real atanl(real x);
- double atan2(double y, double x);
- float atan2f(float y, float x);
- real atan2l(real y, real x);
- double cos(double x);
- float cosf(float x);
- real cosl(real x);
- double sin(double x);
- float sinf(float x);
- real sinl(real x);
- double tan(double x);
- float tanf(float x);
- real tanl(real x);
- double acosh(double x);
- float acoshf(float x);
- real acoshl(real x);
- double asinh(double x);
- float asinhf(float x);
- real asinhl(real x);
- double atanh(double x);
- float atanhf(float x);
- real atanhl(real x);
- double cosh(double x);
- float coshf(float x);
- real coshl(real x);
- double sinh(double x);
- float sinhf(float x);
- real sinhl(real x);
- double tanh(double x);
- float tanhf(float x);
- real tanhl(real x);
- double exp(double x);
- float expf(float x);
- real expl(real x);
- double exp2(double x);
- float exp2f(float x);
- real exp2l(real x);
- double expm1(double x);
- float expm1f(float x);
- real expm1l(real x);
- double frexp(double value, int* exp);
- float frexpf(float value, int* exp);
- real frexpl(real value, int* exp);
- int ilogb(double x);
- int ilogbf(float x);
- int ilogbl(real x);
- double ldexp(double x, int exp);
- float ldexpf(float x, int exp);
- real ldexpl(real x, int exp);
- double log(double x);
- float logf(float x);
- real logl(real x);
- double log10(double x);
- float log10f(float x);
- real log10l(real x);
- double log1p(double x);
- float log1pf(float x);
- real log1pl(real x);
- double log2(double x);
- float log2f(float x);
- real log2l(real x);
- double logb(double x);
- float logbf(float x);
- real logbl(real x);
- double modf(double value, double* iptr);
- float modff(float value, float* iptr);
- real modfl(real value, real* iptr);
- double scalbn(double x, int n);
- float scalbnf(float x, int n);
- real scalbnl(real x, int n);
- double scalbln(double x, c_long n);
- float scalblnf(float x, c_long n);
- real scalblnl(real x, c_long n);
- double cbrt(double x);
- float cbrtf(float x);
- real cbrtl(real x);
- double fabs(double x);
- float fabsf(float x);
- real fabsl(real x);
- double hypot(double x, double y);
- float hypotf(float x, float y);
- real hypotl(real x, real y);
- double pow(double x, double y);
- float powf(float x, float y);
- real powl(real x, real y);
- double sqrt(double x);
- float sqrtf(float x);
- real sqrtl(real x);
- double erf(double x);
- float erff(float x);
- real erfl(real x);
- double erfc(double x);
- float erfcf(float x);
- real erfcl(real x);
- double lgamma(double x);
- float lgammaf(float x);
- real lgammal(real x);
- double tgamma(double x);
- float tgammaf(float x);
- real tgammal(real x);
- double ceil(double x);
- float ceilf(float x);
- real ceill(real x);
- double floor(double x);
- float floorf(float x);
- real floorl(real x);
- double nearbyint(double x);
- float nearbyintf(float x);
- real nearbyintl(real x);
- double rint(double x);
- float rintf(float x);
- real rintl(real x);
- c_long lrint(double x);
- c_long lrintf(float x);
- c_long lrintl(real x);
- long llrint(double x);
- long llrintf(float x);
- long llrintl(real x);
- double round(double x);
- float roundf(float x);
- real roundl(real x);
- c_long lround(double x);
- c_long lroundf(float x);
- c_long lroundl(real x);
- long llround(double x);
- long llroundf(float x);
- long llroundl(real x);
- double trunc(double x);
- float truncf(float x);
- real truncl(real x);
- double fmod(double x, double y);
- float fmodf(float x, float y);
- real fmodl(real x, real y);
- double remainder(double x, double y);
- float remainderf(float x, float y);
- real remainderl(real x, real y);
- double remquo(double x, double y, int* quo);
- float remquof(float x, float y, int* quo);
- real remquol(real x, real y, int* quo);
- double copysign(double x, double y);
- float copysignf(float x, float y);
- real copysignl(real x, real y);
- double nan(char* tagp);
- float nanf(char* tagp);
- real nanl(char* tagp);
- double nextafter(double x, double y);
- float nextafterf(float x, float y);
- real nextafterl(real x, real y);
- double nexttoward(double x, real y);
- float nexttowardf(float x, real y);
- real nexttowardl(real x, real y);
- double fdim(double x, double y);
- float fdimf(float x, float y);
- real fdiml(real x, real y);
- double fmax(double x, double y);
- float fmaxf(float x, float y);
- real fmaxl(real x, real y);
- double fmin(double x, double y);
- float fminf(float x, float y);
- real fminl(real x, real y);
- double fma(double x, double y, double z);
- float fmaf(float x, float y, float z);
- real fmal(real x, real y, real z);
-}
-}
-
+// D import file generated from 'src/core/stdc/math.d'
+module core.stdc.math;
+private import core.stdc.config;
+
+extern (C) nothrow pure
+{
+ alias float float_t;
+ alias double double_t;
+ enum double HUGE_VAL = (double).infinity;
+ enum double HUGE_VALF = (float).infinity;
+ enum double HUGE_VALL = (real).infinity;
+ enum float INFINITY = (float).infinity;
+ enum float NAN = (float).nan;
+ enum int FP_ILOGB0 = (int).min;
+ enum int FP_ILOGBNAN = (int).min;
+ enum int MATH_ERRNO = 1;
+ enum int MATH_ERREXCEPT = 2;
+ enum int math_errhandling = MATH_ERRNO | MATH_ERREXCEPT;
+ version (none)
+{
+ int fpclassify(float x);
+ int fpclassify(double x);
+ int fpclassify(real x);
+ int isfinite(float x);
+ int isfinite(double x);
+ int isfinite(real x);
+ int isinf(float x);
+ int isinf(double x);
+ int isinf(real x);
+ int isnan(float x);
+ int isnan(double x);
+ int isnan(real x);
+ int isnormal(float x);
+ int isnormal(double x);
+ int isnormal(real x);
+ int signbit(float x);
+ int signbit(double x);
+ int signbit(real x);
+ int isgreater(float x, float y);
+ int isgreater(double x, double y);
+ int isgreater(real x, real y);
+ int isgreaterequal(float x, float y);
+ int isgreaterequal(double x, double y);
+ int isgreaterequal(real x, real y);
+ int isless(float x, float y);
+ int isless(double x, double y);
+ int isless(real x, real y);
+ int islessequal(float x, float y);
+ int islessequal(double x, double y);
+ int islessequal(real x, real y);
+ int islessgreater(float x, float y);
+ int islessgreater(double x, double y);
+ int islessgreater(real x, real y);
+ int isunordered(float x, float y);
+ int isunordered(double x, double y);
+ int isunordered(real x, real y);
+}
+ version (DigitalMars)
+{
+ version (Windows)
+{
+ version = DigitalMarsWin32;
+}
+}
+ version (DigitalMarsWin32)
+{
+ enum
+{
+FP_NANS = 0,
+FP_NANQ = 1,
+FP_INFINITE = 2,
+FP_NORMAL = 3,
+FP_SUBNORMAL = 4,
+FP_ZERO = 5,
+FP_NAN = FP_NANQ,
+FP_EMPTY = 6,
+FP_UNSUPPORTED = 7,
+}
+ enum
+{
+FP_FAST_FMA = 0,
+FP_FAST_FMAF = 0,
+FP_FAST_FMAL = 0,
+}
+ uint __fpclassify_f(float x);
+ uint __fpclassify_d(double x);
+ uint __fpclassify_ld(real x);
+ extern (D)
+{
+ int fpclassify(float x)
+{
+return __fpclassify_f(x);
+}
+ int fpclassify(double x)
+{
+return __fpclassify_d(x);
+}
+ int fpclassify(real x)
+{
+return (real).sizeof == (double).sizeof ? __fpclassify_d(x) : __fpclassify_ld(x);
+}
+ int isfinite(float x)
+{
+return fpclassify(x) >= FP_NORMAL;
+}
+ int isfinite(double x)
+{
+return fpclassify(x) >= FP_NORMAL;
+}
+ int isfinite(real x)
+{
+return fpclassify(x) >= FP_NORMAL;
+}
+ int isinf(float x)
+{
+return fpclassify(x) == FP_INFINITE;
+}
+ int isinf(double x)
+{
+return fpclassify(x) == FP_INFINITE;
+}
+ int isinf(real x)
+{
+return fpclassify(x) == FP_INFINITE;
+}
+ int isnan(float x)
+{
+return fpclassify(x) <= FP_NANQ;
+}
+ int isnan(double x)
+{
+return fpclassify(x) <= FP_NANQ;
+}
+ int isnan(real x)
+{
+return fpclassify(x) <= FP_NANQ;
+}
+ int isnormal(float x)
+{
+return fpclassify(x) == FP_NORMAL;
+}
+ int isnormal(double x)
+{
+return fpclassify(x) == FP_NORMAL;
+}
+ int isnormal(real x)
+{
+return fpclassify(x) == FP_NORMAL;
+}
+ int signbit(float x)
+{
+return (cast(short*)&x)[1] & 32768;
+}
+ int signbit(double x)
+{
+return (cast(short*)&x)[3] & 32768;
+}
+ int signbit(real x)
+{
+return (real).sizeof == (double).sizeof ? (cast(short*)&x)[3] & 32768 : (cast(short*)&x)[4] & 32768;
+}
+}
+}
+else
+{
+ version (linux)
+{
+ enum
+{
+FP_NAN,
+FP_INFINITE,
+FP_ZERO,
+FP_SUBNORMAL,
+FP_NORMAL,
+}
+ enum
+{
+FP_FAST_FMA = 0,
+FP_FAST_FMAF = 0,
+FP_FAST_FMAL = 0,
+}
+ int __fpclassifyf(float x);
+ int __fpclassify(double x);
+ int __fpclassifyl(real x);
+ int __finitef(float x);
+ int __finite(double x);
+ int __finitel(real x);
+ int __isinff(float x);
+ int __isinf(double x);
+ int __isinfl(real x);
+ int __isnanf(float x);
+ int __isnan(double x);
+ int __isnanl(real x);
+ int __signbitf(float x);
+ int __signbit(double x);
+ int __signbitl(real x);
+ extern (D)
+{
+ int fpclassify(float x)
+{
+return __fpclassifyf(x);
+}
+ int fpclassify(double x)
+{
+return __fpclassify(x);
+}
+ int fpclassify(real x)
+{
+return (real).sizeof == (double).sizeof ? __fpclassify(x) : __fpclassifyl(x);
+}
+ int isfinite(float x)
+{
+return __finitef(x);
+}
+ int isfinite(double x)
+{
+return __finite(x);
+}
+ int isfinite(real x)
+{
+return (real).sizeof == (double).sizeof ? __finite(x) : __finitel(x);
+}
+ int isinf(float x)
+{
+return __isinff(x);
+}
+ int isinf(double x)
+{
+return __isinf(x);
+}
+ int isinf(real x)
+{
+return (real).sizeof == (double).sizeof ? __isinf(x) : __isinfl(x);
+}
+ int isnan(float x)
+{
+return __isnanf(x);
+}
+ int isnan(double x)
+{
+return __isnan(x);
+}
+ int isnan(real x)
+{
+return (real).sizeof == (double).sizeof ? __isnan(x) : __isnanl(x);
+}
+ int isnormal(float x)
+{
+return fpclassify(x) == FP_NORMAL;
+}
+ int isnormal(double x)
+{
+return fpclassify(x) == FP_NORMAL;
+}
+ int isnormal(real x)
+{
+return fpclassify(x) == FP_NORMAL;
+}
+ int signbit(float x)
+{
+return __signbitf(x);
+}
+ int signbit(double x)
+{
+return __signbit(x);
+}
+ int signbit(real x)
+{
+return (real).sizeof == (double).sizeof ? __signbit(x) : __signbitl(x);
+}
+}
+}
+else
+{
+ version (OSX)
+{
+ enum
+{
+FP_NAN = 1,
+FP_INFINITE = 2,
+FP_ZERO = 3,
+FP_NORMAL = 4,
+FP_SUBNORMAL = 5,
+FP_SUPERNORMAL = 6,
+}
+ enum
+{
+FP_FAST_FMA = 0,
+FP_FAST_FMAF = 0,
+FP_FAST_FMAL = 0,
+}
+ int __fpclassifyf(float x);
+ int __fpclassifyd(double x);
+ int __fpclassify(real x);
+ int __isfinitef(float x);
+ int __isfinited(double x);
+ int __isfinite(real x);
+ int __isinff(float x);
+ int __isinfd(double x);
+ int __isinf(real x);
+ int __isnanf(float x);
+ int __isnand(double x);
+ int __isnan(real x);
+ int __signbitf(float x);
+ int __signbitd(double x);
+ int __signbitl(real x);
+ extern (D)
+{
+ int fpclassify(float x)
+{
+return __fpclassifyf(x);
+}
+ int fpclassify(double x)
+{
+return __fpclassifyd(x);
+}
+ int fpclassify(real x)
+{
+return (real).sizeof == (double).sizeof ? __fpclassifyd(x) : __fpclassify(x);
+}
+ int isfinite(float x)
+{
+return __isfinitef(x);
+}
+ int isfinite(double x)
+{
+return __isfinited(x);
+}
+ int isfinite(real x)
+{
+return (real).sizeof == (double).sizeof ? __isfinited(x) : __isfinite(x);
+}
+ int isinf(float x)
+{
+return __isinff(x);
+}
+ int isinf(double x)
+{
+return __isinfd(x);
+}
+ int isinf(real x)
+{
+return (real).sizeof == (double).sizeof ? __isinfd(x) : __isinf(x);
+}
+ int isnan(float x)
+{
+return __isnanf(x);
+}
+ int isnan(double x)
+{
+return __isnand(x);
+}
+ int isnan(real x)
+{
+return (real).sizeof == (double).sizeof ? __isnand(x) : __isnan(x);
+}
+ int isnormal(float x)
+{
+return fpclassify(x) == FP_NORMAL;
+}
+ int isnormal(double x)
+{
+return fpclassify(x) == FP_NORMAL;
+}
+ int isnormal(real x)
+{
+return fpclassify(x) == FP_NORMAL;
+}
+ int signbit(float x)
+{
+return __signbitf(x);
+}
+ int signbit(double x)
+{
+return __signbitd(x);
+}
+ int signbit(real x)
+{
+return (real).sizeof == (double).sizeof ? __signbitd(x) : __signbitl(x);
+}
+}
+}
+else
+{
+ version (FreeBSD)
+{
+ enum
+{
+FP_INFINITE = 1,
+FP_NAN = 2,
+FP_NORMAL = 4,
+FP_SUBNORMAL = 8,
+FP_ZERO = 16,
+}
+ enum
+{
+FP_FAST_FMA = 0,
+FP_FAST_FMAF = 0,
+FP_FAST_FMAL = 0,
+}
+ int __fpclassifyd(double);
+ int __fpclassifyf(float);
+ int __fpclassifyl(real);
+ int __isfinitef(float);
+ int __isfinite(double);
+ int __isfinitel(real);
+ int __isinff(float);
+ int __isinfl(real);
+ int __isnanl(real);
+ int __isnormalf(float);
+ int __isnormal(double);
+ int __isnormall(real);
+ int __signbit(double);
+ int __signbitf(float);
+ int __signbitl(real);
+ extern (D)
+{
+ int fpclassify(float x)
+{
+return __fpclassifyf(x);
+}
+ int fpclassify(double x)
+{
+return __fpclassifyd(x);
+}
+ int fpclassify(real x)
+{
+return __fpclassifyl(x);
+}
+ int isfinite(float x)
+{
+return __isfinitef(x);
+}
+ int isfinite(double x)
+{
+return __isfinite(x);
+}
+ int isfinite(real x)
+{
+return __isfinitel(x);
+}
+ int isinf(float x)
+{
+return __isinff(x);
+}
+ int isinf(double x)
+{
+return __isinfl(x);
+}
+ int isinf(real x)
+{
+return __isinfl(x);
+}
+ int isnan(float x)
+{
+return __isnanl(x);
+}
+ int isnan(double x)
+{
+return __isnanl(x);
+}
+ int isnan(real x)
+{
+return __isnanl(x);
+}
+ int isnormal(float x)
+{
+return __isnormalf(x);
+}
+ int isnormal(double x)
+{
+return __isnormal(x);
+}
+ int isnormal(real x)
+{
+return __isnormall(x);
+}
+ int signbit(float x)
+{
+return __signbitf(x);
+}
+ int signbit(double x)
+{
+return __signbit(x);
+}
+ int signbit(real x)
+{
+return __signbit(x);
+}
+}
+}
+}
+}
+}
+ extern (D)
+{
+ int isgreater(float x, float y)
+{
+return !(x !> y);
+}
+ int isgreater(double x, double y)
+{
+return !(x !> y);
+}
+ int isgreater(real x, real y)
+{
+return !(x !> y);
+}
+ int isgreaterequal(float x, float y)
+{
+return !(x !>= y);
+}
+ int isgreaterequal(double x, double y)
+{
+return !(x !>= y);
+}
+ int isgreaterequal(real x, real y)
+{
+return !(x !>= y);
+}
+ int isless(float x, float y)
+{
+return !(x !< y);
+}
+ int isless(double x, double y)
+{
+return !(x !< y);
+}
+ int isless(real x, real y)
+{
+return !(x !< y);
+}
+ int islessequal(float x, float y)
+{
+return !(x !<= y);
+}
+ int islessequal(double x, double y)
+{
+return !(x !<= y);
+}
+ int islessequal(real x, real y)
+{
+return !(x !<= y);
+}
+ int islessgreater(float x, float y)
+{
+return !(x !<> y);
+}
+ int islessgreater(double x, double y)
+{
+return !(x !<> y);
+}
+ int islessgreater(real x, real y)
+{
+return !(x !<> y);
+}
+ int isunordered(float x, float y)
+{
+return x !<>= y;
+}
+ int isunordered(double x, double y)
+{
+return x !<>= y;
+}
+ int isunordered(real x, real y)
+{
+return x !<>= y;
+}
+}
+ version (FreeBSD)
+{
+ version (all)
+{
+ real acosl(real x)
+{
+return acos(x);
+}
+ real asinl(real x)
+{
+return asin(x);
+}
+ real atanl(real x)
+{
+return atan(x);
+}
+ real atan2l(real y, real x)
+{
+return atan2(y,x);
+}
+ real cosl(real x)
+{
+return cos(x);
+}
+ real sinl(real x)
+{
+return sin(x);
+}
+ real tanl(real x)
+{
+return tan(x);
+}
+ real exp2l(real x)
+{
+return exp2(x);
+}
+ real frexpl(real value, int* exp)
+{
+return frexp(value,exp);
+}
+ int ilogbl(real x)
+{
+return ilogb(x);
+}
+ real ldexpl(real x, int exp)
+{
+return ldexp(x,exp);
+}
+ real logbl(real x)
+{
+return logb(x);
+}
+ real scalbnl(real x, int n)
+{
+return scalbn(x,n);
+}
+ real scalblnl(real x, c_long n)
+{
+return scalbln(x,n);
+}
+ real fabsl(real x)
+{
+return fabs(x);
+}
+ real hypotl(real x, real y)
+{
+return hypot(x,y);
+}
+ real sqrtl(real x)
+{
+return sqrt(x);
+}
+ real ceill(real x)
+{
+return ceil(x);
+}
+ real floorl(real x)
+{
+return floor(x);
+}
+ real nearbyintl(real x)
+{
+return nearbyint(x);
+}
+ real rintl(real x)
+{
+return rint(x);
+}
+ c_long lrintl(real x)
+{
+return lrint(x);
+}
+ real roundl(real x)
+{
+return round(x);
+}
+ c_long lroundl(real x)
+{
+return lround(x);
+}
+ long llroundl(real x)
+{
+return llround(x);
+}
+ real truncl(real x)
+{
+return trunc(x);
+}
+ real fmodl(real x, real y)
+{
+return fmod(x,y);
+}
+ real remainderl(real x, real y)
+{
+return remainder(x,y);
+}
+ real remquol(real x, real y, int* quo)
+{
+return remquo(x,y,quo);
+}
+ real copysignl(real x, real y)
+{
+return copysign(x,y);
+}
+ real nextafterl(real x, real y)
+{
+return nextafter(x,y);
+}
+ real nexttowardl(real x, real y)
+{
+return nexttoward(x,y);
+}
+ real fdiml(real x, real y)
+{
+return fdim(x,y);
+}
+ real fmaxl(real x, real y)
+{
+return fmax(x,y);
+}
+ real fminl(real x, real y)
+{
+return fmin(x,y);
+}
+ real fmal(real x, real y, real z)
+{
+return fma(x,y,z);
+}
+}
+else
+{
+ real acosl(real x);
+ real asinl(real x);
+ real atanl(real x);
+ real atan2l(real y, real x);
+ real cosl(real x);
+ real sinl(real x);
+ real tanl(real x);
+ real exp2l(real x);
+ real frexpl(real value, int* exp);
+ int ilogbl(real x);
+ real ldexpl(real x, int exp);
+ real logbl(real x);
+ real modfl(real value, real* iptr);
+ real scalbnl(real x, int n);
+ real scalblnl(real x, c_long n);
+ real fabsl(real x);
+ real hypotl(real x, real y);
+ real sqrtl(real x);
+ real ceill(real x);
+ real floorl(real x);
+ real nearbyintl(real x);
+ real rintl(real x);
+ c_long lrintl(real x);
+ real roundl(real x);
+ c_long lroundl(real x);
+ long llroundl(real x);
+ real truncl(real x);
+ real fmodl(real x, real y);
+ real remainderl(real x, real y);
+ real remquol(real x, real y, int* quo);
+ real copysignl(real x, real y);
+ double nan(char* tagp);
+ float nanf(char* tagp);
+ real nanl(char* tagp);
+ real nextafterl(real x, real y);
+ real nexttowardl(real x, real y);
+ real fdiml(real x, real y);
+ real fmaxl(real x, real y);
+ real fminl(real x, real y);
+ real fmal(real x, real y, real z);
+}
+ double acos(double x);
+ float acosf(float x);
+ double asin(double x);
+ float asinf(float x);
+ double atan(double x);
+ float atanf(float x);
+ double atan2(double y, double x);
+ float atan2f(float y, float x);
+ double cos(double x);
+ float cosf(float x);
+ double sin(double x);
+ float sinf(float x);
+ double tan(double x);
+ float tanf(float x);
+ double acosh(double x);
+ float acoshf(float x);
+ real acoshl(real x)
+{
+return acosh(x);
+}
+ double asinh(double x);
+ float asinhf(float x);
+ real asinhl(real x)
+{
+return asinh(x);
+}
+ double atanh(double x);
+ float atanhf(float x);
+ real atanhl(real x)
+{
+return atanh(x);
+}
+ double cosh(double x);
+ float coshf(float x);
+ real coshl(real x)
+{
+return cosh(x);
+}
+ double sinh(double x);
+ float sinhf(float x);
+ real sinhl(real x)
+{
+return sinh(x);
+}
+ double tanh(double x);
+ float tanhf(float x);
+ real tanhl(real x)
+{
+return tanh(x);
+}
+ double exp(double x);
+ float expf(float x);
+ real expl(real x)
+{
+return exp(x);
+}
+ double exp2(double x);
+ float exp2f(float x);
+ double expm1(double x);
+ float expm1f(float x);
+ real expm1l(real x)
+{
+return expm1(x);
+}
+ double frexp(double value, int* exp);
+ float frexpf(float value, int* exp);
+ int ilogb(double x);
+ int ilogbf(float x);
+ double ldexp(double x, int exp);
+ float ldexpf(float x, int exp);
+ double log(double x);
+ float logf(float x);
+ real logl(real x)
+{
+return log(x);
+}
+ double log10(double x);
+ float log10f(float x);
+ real log10l(real x)
+{
+return log10(x);
+}
+ double log1p(double x);
+ float log1pf(float x);
+ real log1pl(real x)
+{
+return log1p(x);
+}
+ private enum real ONE_LN2 = 1 / 0xb.17217f7d1cf79acp-4L;
+
+ double log2(double x)
+{
+return log(x) * ONE_LN2;
+}
+ float log2f(float x)
+{
+return logf(x) * ONE_LN2;
+}
+ real log2l(real x)
+{
+return logl(x) * ONE_LN2;
+}
+ double logb(double x);
+ float logbf(float x);
+ double modf(double value, double* iptr);
+ float modff(float value, float* iptr);
+ double scalbn(double x, int n);
+ float scalbnf(float x, int n);
+ double scalbln(double x, c_long n);
+ float scalblnf(float x, c_long n);
+ double cbrt(double x);
+ float cbrtf(float x);
+ real cbrtl(real x)
+{
+return cbrt(x);
+}
+ double fabs(double x);
+ float fabsf(float x);
+ double hypot(double x, double y);
+ float hypotf(float x, float y);
+ double pow(double x, double y);
+ float powf(float x, float y);
+ real powl(real x, real y)
+{
+return pow(x,y);
+}
+ double sqrt(double x);
+ float sqrtf(float x);
+ double erf(double x);
+ float erff(float x);
+ real erfl(real x)
+{
+return erf(x);
+}
+ double erfc(double x);
+ float erfcf(float x);
+ real erfcl(real x)
+{
+return erfc(x);
+}
+ double lgamma(double x);
+ float lgammaf(float x);
+ real lgammal(real x)
+{
+return lgamma(x);
+}
+ double tgamma(double x);
+ float tgammaf(float x);
+ real tgammal(real x)
+{
+return tgamma(x);
+}
+ double ceil(double x);
+ float ceilf(float x);
+ double floor(double x);
+ float floorf(float x);
+ double nearbyint(double x);
+ float nearbyintf(float x);
+ double rint(double x);
+ float rintf(float x);
+ c_long lrint(double x);
+ c_long lrintf(float x);
+ long llrint(double x);
+ long llrintf(float x);
+ long llrintl(real x)
+{
+return llrint(x);
+}
+ double round(double x);
+ float roundf(float x);
+ c_long lround(double x);
+ c_long lroundf(float x);
+ long llround(double x);
+ long llroundf(float x);
+ double trunc(double x);
+ float truncf(float x);
+ double fmod(double x, double y);
+ float fmodf(float x, float y);
+ double remainder(double x, double y);
+ float remainderf(float x, float y);
+ double remquo(double x, double y, int* quo);
+ float remquof(float x, float y, int* quo);
+ double copysign(double x, double y);
+ float copysignf(float x, float y);
+ double nextafter(double x, double y);
+ float nextafterf(float x, float y);
+ double nexttoward(double x, real y);
+ float nexttowardf(float x, real y);
+ double fdim(double x, double y);
+ float fdimf(float x, float y);
+ double fmax(double x, double y);
+ float fmaxf(float x, float y);
+ double fmin(double x, double y);
+ float fminf(float x, float y);
+ double fma(double x, double y, double z);
+ float fmaf(float x, float y, float z);
+}
+else
+{
+ double acos(double x);
+ float acosf(float x);
+ real acosl(real x);
+ double asin(double x);
+ float asinf(float x);
+ real asinl(real x);
+ double atan(double x);
+ float atanf(float x);
+ real atanl(real x);
+ double atan2(double y, double x);
+ float atan2f(float y, float x);
+ real atan2l(real y, real x);
+ double cos(double x);
+ float cosf(float x);
+ real cosl(real x);
+ double sin(double x);
+ float sinf(float x);
+ real sinl(real x);
+ double tan(double x);
+ float tanf(float x);
+ real tanl(real x);
+ double acosh(double x);
+ float acoshf(float x);
+ real acoshl(real x);
+ double asinh(double x);
+ float asinhf(float x);
+ real asinhl(real x);
+ double atanh(double x);
+ float atanhf(float x);
+ real atanhl(real x);
+ double cosh(double x);
+ float coshf(float x);
+ real coshl(real x);
+ double sinh(double x);
+ float sinhf(float x);
+ real sinhl(real x);
+ double tanh(double x);
+ float tanhf(float x);
+ real tanhl(real x);
+ double exp(double x);
+ float expf(float x);
+ real expl(real x);
+ double exp2(double x);
+ float exp2f(float x);
+ real exp2l(real x);
+ double expm1(double x);
+ float expm1f(float x);
+ real expm1l(real x);
+ double frexp(double value, int* exp);
+ float frexpf(float value, int* exp);
+ real frexpl(real value, int* exp);
+ int ilogb(double x);
+ int ilogbf(float x);
+ int ilogbl(real x);
+ double ldexp(double x, int exp);
+ float ldexpf(float x, int exp);
+ real ldexpl(real x, int exp);
+ double log(double x);
+ float logf(float x);
+ real logl(real x);
+ double log10(double x);
+ float log10f(float x);
+ real log10l(real x);
+ double log1p(double x);
+ float log1pf(float x);
+ real log1pl(real x);
+ double log2(double x);
+ float log2f(float x);
+ real log2l(real x);
+ double logb(double x);
+ float logbf(float x);
+ real logbl(real x);
+ double modf(double value, double* iptr);
+ float modff(float value, float* iptr);
+ real modfl(real value, real* iptr);
+ double scalbn(double x, int n);
+ float scalbnf(float x, int n);
+ real scalbnl(real x, int n);
+ double scalbln(double x, c_long n);
+ float scalblnf(float x, c_long n);
+ real scalblnl(real x, c_long n);
+ double cbrt(double x);
+ float cbrtf(float x);
+ real cbrtl(real x);
+ double fabs(double x);
+ float fabsf(float x);
+ real fabsl(real x);
+ double hypot(double x, double y);
+ float hypotf(float x, float y);
+ real hypotl(real x, real y);
+ double pow(double x, double y);
+ float powf(float x, float y);
+ real powl(real x, real y);
+ double sqrt(double x);
+ float sqrtf(float x);
+ real sqrtl(real x);
+ double erf(double x);
+ float erff(float x);
+ real erfl(real x);
+ double erfc(double x);
+ float erfcf(float x);
+ real erfcl(real x);
+ double lgamma(double x);
+ float lgammaf(float x);
+ real lgammal(real x);
+ double tgamma(double x);
+ float tgammaf(float x);
+ real tgammal(real x);
+ double ceil(double x);
+ float ceilf(float x);
+ real ceill(real x);
+ double floor(double x);
+ float floorf(float x);
+ real floorl(real x);
+ double nearbyint(double x);
+ float nearbyintf(float x);
+ real nearbyintl(real x);
+ double rint(double x);
+ float rintf(float x);
+ real rintl(real x);
+ c_long lrint(double x);
+ c_long lrintf(float x);
+ c_long lrintl(real x);
+ long llrint(double x);
+ long llrintf(float x);
+ long llrintl(real x);
+ double round(double x);
+ float roundf(float x);
+ real roundl(real x);
+ c_long lround(double x);
+ c_long lroundf(float x);
+ c_long lroundl(real x);
+ long llround(double x);
+ long llroundf(float x);
+ long llroundl(real x);
+ double trunc(double x);
+ float truncf(float x);
+ real truncl(real x);
+ double fmod(double x, double y);
+ float fmodf(float x, float y);
+ real fmodl(real x, real y);
+ double remainder(double x, double y);
+ float remainderf(float x, float y);
+ real remainderl(real x, real y);
+ double remquo(double x, double y, int* quo);
+ float remquof(float x, float y, int* quo);
+ real remquol(real x, real y, int* quo);
+ double copysign(double x, double y);
+ float copysignf(float x, float y);
+ real copysignl(real x, real y);
+ double nan(char* tagp);
+ float nanf(char* tagp);
+ real nanl(char* tagp);
+ double nextafter(double x, double y);
+ float nextafterf(float x, float y);
+ real nextafterl(real x, real y);
+ double nexttoward(double x, real y);
+ float nexttowardf(float x, real y);
+ real nexttowardl(real x, real y);
+ double fdim(double x, double y);
+ float fdimf(float x, float y);
+ real fdiml(real x, real y);
+ double fmax(double x, double y);
+ float fmaxf(float x, float y);
+ real fmaxl(real x, real y);
+ double fmin(double x, double y);
+ float fminf(float x, float y);
+ real fminl(real x, real y);
+ double fma(double x, double y, double z);
+ float fmaf(float x, float y, float z);
+ real fmal(real x, real y, real z);
+}
+}
+
+
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/import/core/stdc/stdlib.di druntime/import/core/stdc/stdlib.di
--- druntime-orig/import/core/stdc/stdlib.di 2010-12-20 10:27:04.000000000 +0300
+++ druntime/import/core/stdc/stdlib.di 2011-01-05 14:40:22.000000000 +0300
@@ -1,72 +1,89 @@
-// D import file generated from 'src\core\stdc\stdlib.d'
-module core.stdc.stdlib;
-private import core.stdc.config;
-
-public import core.stdc.stddef;
-
-extern (C) nothrow
-{
- struct div_t
-{
- int quot;
- int rem;
-}
- struct ldiv_t
-{
- int quot;
- int rem;
-}
- struct lldiv_t
-{
- long quot;
- long rem;
-}
- enum EXIT_SUCCESS = 0;
- enum EXIT_FAILURE = 1;
- enum RAND_MAX = 32767;
- enum MB_CUR_MAX = 1;
- double atof(in char* nptr);
- int atoi(in char* nptr);
- c_long atol(in char* nptr);
- long atoll(in char* nptr);
- double strtod(in char* nptr, char** endptr);
- float strtof(in char* nptr, char** endptr);
- real strtold(in char* nptr, char** endptr);
- c_long strtol(in char* nptr, char** endptr, int base);
- long strtoll(in char* nptr, char** endptr, int base);
- c_ulong strtoul(in char* nptr, char** endptr, int base);
- ulong strtoull(in char* nptr, char** endptr, int base);
- int rand();
- void srand(uint seed);
- void* malloc(size_t size);
- void* calloc(size_t nmemb, size_t size);
- void* realloc(void* ptr, size_t size);
- void free(void* ptr);
- void abort();
- void exit(int status);
- int atexit(void function() func);
- void _Exit(int status);
- char* getenv(in char* name);
- int system(in char* string);
- void* bsearch(in void* key, in void* base, size_t nmemb, size_t size, int function(in void*, in void*) compar);
- void qsort(void* base, size_t nmemb, size_t size, int function(in void*, in void*) compar);
- pure int abs(int j);
-
- pure c_long labs(c_long j);
-
- pure long llabs(long j);
-
- div_t div(int numer, int denom);
- ldiv_t ldiv(c_long numer, c_long denom);
- lldiv_t lldiv(long numer, long denom);
- int mblen(in char* s, size_t n);
- int mbtowc(wchar_t* pwc, in char* s, size_t n);
- int wctomb(char* s, wchar_t wc);
- size_t mbstowcs(wchar_t* pwcs, in char* s, size_t n);
- size_t wcstombs(char* s, in wchar_t* pwcs, size_t n);
- version (DigitalMars)
-{
- void* alloca(size_t size);
-}
-}
-
+// D import file generated from 'src/core/stdc/stdlib.d'
+module core.stdc.stdlib;
+private import core.stdc.config;
+
+public import core.stdc.stddef;
+
+extern (C) nothrow
+{
+ struct div_t
+{
+ int quot;
+ int rem;
+}
+ struct ldiv_t
+{
+ int quot;
+ int rem;
+}
+ struct lldiv_t
+{
+ long quot;
+ long rem;
+}
+ enum EXIT_SUCCESS = 0;
+ enum EXIT_FAILURE = 1;
+ enum RAND_MAX = 32767;
+ enum MB_CUR_MAX = 1;
+ double atof(in char* nptr);
+ int atoi(in char* nptr);
+ c_long atol(in char* nptr);
+ long atoll(in char* nptr);
+ double strtod(in char* nptr, char** endptr);
+ float strtof(in char* nptr, char** endptr);
+ real strtold(in char* nptr, char** endptr);
+ c_long strtol(in char* nptr, char** endptr, int base);
+ long strtoll(in char* nptr, char** endptr, int base);
+ c_ulong strtoul(in char* nptr, char** endptr, int base);
+ ulong strtoull(in char* nptr, char** endptr, int base);
+ int rand();
+ void srand(uint seed);
+ void* malloc(size_t size);
+ void* calloc(size_t nmemb, size_t size);
+ void* realloc(void* ptr, size_t size);
+ void free(void* ptr);
+ void abort();
+ void exit(int status);
+ int atexit(void function() func);
+ void _Exit(int status);
+ char* getenv(in char* name);
+ int system(in char* string);
+ void* bsearch(in void* key, in void* base, size_t nmemb, size_t size, int function(in void*, in void*) compar);
+ void qsort(void* base, size_t nmemb, size_t size, int function(in void*, in void*) compar);
+ pure int abs(int j);
+
+ pure c_long labs(c_long j);
+
+ pure long llabs(long j);
+
+ div_t div(int numer, int denom);
+ ldiv_t ldiv(c_long numer, c_long denom);
+ lldiv_t lldiv(long numer, long denom);
+ int mblen(in char* s, size_t n);
+ int mbtowc(wchar_t* pwc, in char* s, size_t n);
+ int wctomb(char* s, wchar_t wc);
+ size_t mbstowcs(wchar_t* pwcs, in char* s, size_t n);
+ size_t wcstombs(char* s, in wchar_t* pwcs, size_t n);
+ version (DigitalMars)
+{
+ void* alloca(size_t size);
+}
+else
+{
+ version (LDC)
+{
+ pragma (alloca)void* alloca(size_t size);
+
+}
+else
+{
+ version (GNU)
+{
+ private import gcc.builtins;
+
+ alias gcc.builtins.__builtin_alloca alloca;
+}
+}
+}
+}
+
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/import/core/vararg.di druntime/import/core/vararg.di
--- druntime-orig/import/core/vararg.di 2010-12-20 10:27:04.000000000 +0300
+++ druntime/import/core/vararg.di 2011-01-05 14:41:51.000000000 +0300
@@ -1,34 +1,45 @@
-// D import file generated from 'src\core\vararg.d'
-module core.vararg;
-version (X86)
-{
- alias void* va_list;
- template va_start(T)
-{
-void va_start(out va_list ap, ref T parmn)
-{
-ap = cast(va_list)(cast(void*)&parmn + (T.sizeof + (int).sizeof - 1 & ~((int).sizeof - 1)));
-}
-}
- template va_arg(T)
-{
-T va_arg(ref va_list ap)
-{
-T arg = *cast(T*)ap;
-ap = cast(va_list)(cast(void*)ap + (T.sizeof + (int).sizeof - 1 & ~((int).sizeof - 1)));
-return arg;
-}
-}
- void va_end(va_list ap)
-{
-}
- void va_copy(out va_list dst, va_list src)
-{
-dst = src;
-}
-}
-else
-{
- public import core.stdc.stdarg;
-
-}
+// D import file generated from 'src/core/vararg.d'
+module core.vararg;
+version (X86)
+{
+ alias void* va_list;
+version (LDC)
+{
+ pragma (va_start)template va_start(T)
+{
+void va_start(va_list ap, ref T);
+}
+
+}
+else
+{
+ template va_start(T)
+{
+void va_start(out va_list ap, ref T parmn)
+{
+ap = cast(va_list)(cast(void*)&parmn + (T.sizeof + size_t.sizeof - 1 & ~(size_t.sizeof - 1)));
+}
+}
+}
+ template va_arg(T)
+{
+T va_arg(ref va_list ap)
+{
+T arg = *cast(T*)ap;
+ap = cast(va_list)(cast(void*)ap + (T.sizeof + (int).sizeof - 1 & ~((int).sizeof - 1)));
+return arg;
+}
+}
+ void va_end(va_list ap)
+{
+}
+ void va_copy(out va_list dst, va_list src)
+{
+dst = src;
+}
+}
+else
+{
+ public import core.stdc.stdarg;
+
+}
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/import/ldc/intrinsics.di druntime/import/ldc/intrinsics.di
--- druntime-orig/import/ldc/intrinsics.di 1970-01-01 03:00:00.000000000 +0300
+++ druntime/import/ldc/intrinsics.di 2011-01-05 14:40:22.000000000 +0300
@@ -0,0 +1,359 @@
+/*
+ * This module holds declarations to LLVM intrinsics.
+ *
+ * See the LLVM language reference for more information:
+ *
+ * - http://llvm.org/docs/LangRef.html#intrinsics
+ *
+ */
+
+module ldc.intrinsics;
+
+// Check for the right compiler
+version(LDC)
+{
+ // OK
+}
+else
+{
+ static assert(false, "This module is only valid for LDC");
+}
+
+//
+// CODE GENERATOR INTRINSICS
+//
+
+
+// The 'llvm.returnaddress' intrinsic attempts to compute a target-specific
+// value indicating the return address of the current function or one of its
+// callers.
+
+pragma(intrinsic, "llvm.returnaddress")
+ void* llvm_returnaddress(uint level);
+
+
+// The 'llvm.frameaddress' intrinsic attempts to return the target-specific
+// frame pointer value for the specified stack frame.
+
+pragma(intrinsic, "llvm.frameaddress")
+ void* llvm_frameaddress(uint level);
+
+
+// The 'llvm.stacksave' intrinsic is used to remember the current state of the
+// function stack, for use with llvm.stackrestore. This is useful for
+// implementing language features like scoped automatic variable sized arrays
+// in C99.
+
+pragma(intrinsic, "llvm.stacksave")
+ void* llvm_stacksave();
+
+
+// The 'llvm.stackrestore' intrinsic is used to restore the state of the
+// function stack to the state it was in when the corresponding llvm.stacksave
+// intrinsic executed. This is useful for implementing language features like
+// scoped automatic variable sized arrays in C99.
+
+pragma(intrinsic, "llvm.stackrestore")
+ void llvm_stackrestore(void* ptr);
+
+
+// The 'llvm.prefetch' intrinsic is a hint to the code generator to insert a
+// prefetch instruction if supported; otherwise, it is a noop. Prefetches have
+// no effect on the behavior of the program but can change its performance
+// characteristics.
+
+pragma(intrinsic, "llvm.prefetch")
+ void llvm_prefetch(void* ptr, uint rw, uint locality);
+
+
+// The 'llvm.pcmarker' intrinsic is a method to export a Program Counter (PC)
+// in a region of code to simulators and other tools. The method is target
+// specific, but it is expected that the marker will use exported symbols to
+// transmit the PC of the marker. The marker makes no guarantees that it will
+// remain with any specific instruction after optimizations. It is possible
+// that the presence of a marker will inhibit optimizations. The intended use
+// is to be inserted after optimizations to allow correlations of simulation
+// runs.
+
+pragma(intrinsic, "llvm.pcmarker")
+ void llvm_pcmarker(uint id);
+
+
+// The 'llvm.readcyclecounter' intrinsic provides access to the cycle counter
+// register (or similar low latency, high accuracy clocks) on those targets that
+// support it. On X86, it should map to RDTSC. On Alpha, it should map to RPCC.
+// As the backing counters overflow quickly (on the order of 9 seconds on
+// alpha), this should only be used for small timings.
+
+pragma(intrinsic, "llvm.readcyclecounter")
+ ulong readcyclecounter();
+
+
+
+
+//
+// STANDARD C LIBRARY INTRINSICS
+//
+
+
+// The 'llvm.memcpy.*' intrinsics copy a block of memory from the source
+// location to the destination location.
+// Note that, unlike the standard libc function, the llvm.memcpy.* intrinsics do
+// not return a value, and takes an extra alignment argument.
+
+version(LDC_LLVMPre28)
+{
+ pragma(intrinsic, "llvm.memcpy.i#")
+ void llvm_memcpy(T)(void* dst, void* src, T len, uint alignment);
+}
+else
+{
+ pragma(intrinsic, "llvm.memcpy.p0i8.p0i8.i#")
+ void llvm_memcpy(T)(void* dst, void* src, T len, uint alignment, bool volatile_ = false);
+}
+
+
+// The 'llvm.memmove.*' intrinsics move a block of memory from the source
+// location to the destination location. It is similar to the 'llvm.memcpy'
+// intrinsic but allows the two memory locations to overlap.
+// Note that, unlike the standard libc function, the llvm.memmove.* intrinsics
+// do not return a value, and takes an extra alignment argument.
+
+
+version(LDC_LLVMPre28)
+{
+ pragma(intrinsic, "llvm.memmove.i#")
+ void llvm_memmove(T)(void* dst, void* src, T len, uint alignment);
+}
+else
+{
+ pragma(intrinsic, "llvm.memmove.p0i8.p0i8.i#")
+ void llvm_memmove(T)(void* dst, void* src, T len, uint alignment, bool volatile_ = false);
+}
+
+
+// The 'llvm.memset.*' intrinsics fill a block of memory with a particular byte
+// value.
+// Note that, unlike the standard libc function, the llvm.memset intrinsic does
+// not return a value, and takes an extra alignment argument.
+
+version(LDC_LLVMPre28)
+{
+ pragma(intrinsic, "llvm.memset.i#")
+ void llvm_memset(T)(void* dst, ubyte val, T len, uint alignment);
+}
+else
+{
+ pragma(intrinsic, "llvm.memset.p0i8.i#")
+ void llvm_memset(T)(void* dst, ubyte val, T len, uint alignment, bool volatile_ = false);
+}
+
+
+// The 'llvm.sqrt' intrinsics return the sqrt of the specified operand,
+// returning the same value as the libm 'sqrt' functions would. Unlike sqrt in
+// libm, however, llvm.sqrt has undefined behavior for negative numbers other
+// than -0.0 (which allows for better optimization, because there is no need to
+// worry about errno being set). llvm.sqrt(-0.0) is defined to return -0.0 like
+// IEEE sqrt.
+
+@safe nothrow pure pragma(intrinsic, "llvm.sqrt.f#")
+ T llvm_sqrt(T)(T val);
+
+
+// The 'llvm.sin.*' intrinsics return the sine of the operand.
+
+@safe nothrow pure pragma(intrinsic, "llvm.sin.f#")
+ T llvm_sin(T)(T val);
+
+
+// The 'llvm.cos.*' intrinsics return the cosine of the operand.
+
+@safe nothrow pure pragma(intrinsic, "llvm.cos.f#")
+ T llvm_cos(T)(T val);
+
+
+// The 'llvm.powi.*' intrinsics return the first operand raised to the specified
+// (positive or negative) power. The order of evaluation of multiplications is
+// not defined. When a vector of floating point type is used, the second
+// argument remains a scalar integer value.
+
+pragma(intrinsic, "llvm.powi.f#")
+ T llvm_powi(T)(T val, int power);
+
+
+// The 'llvm.pow.*' intrinsics return the first operand raised to the specified
+// (positive or negative) power.
+
+pragma(intrinsic, "llvm.pow.f#")
+ T llvm_pow(T)(T val, T power);
+
+
+//
+// BIT MANIPULATION INTRINSICS
+//
+
+// The 'llvm.bswap' family of intrinsics is used to byte swap integer values
+// with an even number of bytes (positive multiple of 16 bits). These are
+// useful for performing operations on data that is not in the target's native
+// byte order.
+
+pragma(intrinsic, "llvm.bswap.i#.i#")
+ T llvm_bswap(T)(T val);
+
+
+// The 'llvm.ctpop' family of intrinsics counts the number of bits set in a
+// value.
+
+pragma(intrinsic, "llvm.ctpop.i#")
+ T llvm_ctpop(T)(T src);
+
+
+// The 'llvm.ctlz' family of intrinsic functions counts the number of leading
+// zeros in a variable.
+
+pragma(intrinsic, "llvm.ctlz.i#")
+ T llvm_ctlz(T)(T src);
+
+
+// The 'llvm.cttz' family of intrinsic functions counts the number of trailing
+// zeros.
+
+pragma(intrinsic, "llvm.cttz.i#")
+ T llvm_cttz(T)(T src);
+
+
+// The 'llvm.part.select' family of intrinsic functions selects a range of bits
+// from an integer value and returns them in the same bit width as the original
+// value.
+
+pragma(intrinsic, "llvm.part.select.i#")
+ T llvm_part_select(T)(T val, uint loBit, uint hiBit);
+
+
+// The 'llvm.part.set' family of intrinsic functions replaces a range of bits
+// in an integer value with another integer value. It returns the integer with
+// the replaced bits.
+
+// TODO
+// declare i17 @llvm.part.set.i17.i9 (i17 %val, i9 %repl, i32 %lo, i32 %hi)
+// declare i29 @llvm.part.set.i29.i9 (i29 %val, i9 %repl, i32 %lo, i32 %hi)
+
+
+
+
+//
+// ATOMIC OPERATIONS AND SYNCHRONIZATION INTRINSICS
+//
+
+// The llvm.memory.barrier intrinsic guarantees ordering between specific
+// pairs of memory access types.
+
+pragma(intrinsic, "llvm.memory.barrier")
+ void llvm_memory_barrier(bool ll, bool ls, bool sl, bool ss, bool device);
+
+// This loads a value in memory and compares it to a given value. If they are
+// equal, it stores a new value into the memory.
+
+pragma(intrinsic, "llvm.atomic.cmp.swap.i#.p0i#")
+ T llvm_atomic_cmp_swap(T)(shared T* ptr, T cmp, T val);
+
+// This intrinsic loads the value stored in memory at ptr and yields the value
+// from memory. It then stores the value in val in the memory at ptr.
+
+pragma(intrinsic, "llvm.atomic.swap.i#.p0i#")
+ T llvm_atomic_swap(T)(T* ptr, T val);
+
+// This intrinsic adds delta to the value stored in memory at ptr. It yields
+// the original value at ptr.
+
+pragma(intrinsic, "llvm.atomic.load.add.i#.p0i#")
+ T llvm_atomic_load_add(T)(shared const T* ptr, T val);
+
+// This intrinsic subtracts delta to the value stored in memory at ptr. It
+// yields the original value at ptr.
+
+pragma(intrinsic, "llvm.atomic.load.sub.i#.p0i#")
+ T llvm_atomic_load_sub(T)(T* ptr, T val);
+
+// These intrinsics bitwise the operation (and, nand, or, xor) delta to the
+// value stored in memory at ptr. It yields the original value at ptr.
+
+pragma(intrinsic, "llvm.atomic.load.and.i#.p0i#")
+ T llvm_atomic_load_and(T)(T* ptr, T val);
+
+pragma(intrinsic, "llvm.atomic.load.nand.i#.p0i#")
+ T llvm_atomic_load_nand(T)(T* ptr, T val);
+
+pragma(intrinsic, "llvm.atomic.load.or.i#.p0i#")
+ T llvm_atomic_load_or(T)(T* ptr, T val);
+
+pragma(intrinsic, "llvm.atomic.load.xor.i#.p0i#")
+ T llvm_atomic_load_xor(T)(T* ptr, T val);
+
+// These intrinsics takes the signed or unsigned minimum or maximum of delta
+// and the value stored in memory at ptr. It yields the original value at ptr.
+
+pragma(intrinsic, "llvm.atomic.load.max.i#.p0i#")
+ T llvm_atomic_load_max(T)(T* ptr, T val);
+
+pragma(intrinsic, "llvm.atomic.load.min.i#.p0i#")
+ T llvm_atomic_load_min(T)(T* ptr, T val);
+
+pragma(intrinsic, "llvm.atomic.load.umax.i#.p0i#")
+ T llvm_atomic_load_umax(T)(T* ptr, T val);
+
+pragma(intrinsic, "llvm.atomic.load.umin.i#.p0i#")
+ T llvm_atomic_load_umin(T)(T* ptr, T val);
+
+
+//
+// ARITHMETIC-WITH-OVERFLOW INTRINSICS
+//
+
+struct OverflowRet(T) {
+ static assert(is(T : int), T.stringof ~ " is not an integer type!");
+ T result;
+ bool overflow;
+}
+
+// Signed and unsigned addition
+pragma(intrinsic, "llvm.sadd.with.overflow.i#")
+ OverflowRet!(T) llvm_sadd_with_overflow(T)(T lhs, T rhs);
+
+pragma(intrinsic, "llvm.uadd.with.overflow.i#")
+ OverflowRet!(T) llvm_uadd_with_overflow(T)(T lhs, T rhs);
+
+
+// Signed and unsigned subtraction
+pragma(intrinsic, "llvm.ssub.with.overflow.i#")
+ OverflowRet!(T) llvm_ssub_with_overflow(T)(T lhs, T rhs);
+
+pragma(intrinsic, "llvm.usub.with.overflow.i#")
+ OverflowRet!(T) llvm_usub_with_overflow(T)(T lhs, T rhs);
+
+
+// Signed and unsigned multiplication
+pragma(intrinsic, "llvm.smul.with.overflow.i#")
+ OverflowRet!(T) llvm_smul_with_overflow(T)(T lhs, T rhs);
+
+/* Note: LLVM documentations says:
+ * Warning: 'llvm.umul.with.overflow' is badly broken.
+ * It is actively being fixed, but it should not currently be used!
+ *
+ * See: http://llvm.org/docs/LangRef.html#int_umul_overflow
+ */
+//pragma(intrinsic, "llvm.umul.with.overflow.i#")
+// OverflowRet!(T) llvm_umul_with_overflow(T)(T lhs, T rhs);
+
+
+//
+// GENERAL INTRINSICS
+//
+
+
+// This intrinsics is lowered to the target dependent trap instruction. If the
+// target does not have a trap instruction, this intrinsic will be lowered to
+// the call of the abort() function.
+
+pragma(intrinsic, "llvm.trap")
+ void llvm_trap();
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/import/ldc/llvmasm.di druntime/import/ldc/llvmasm.di
--- druntime-orig/import/ldc/llvmasm.di 1970-01-01 03:00:00.000000000 +0300
+++ druntime/import/ldc/llvmasm.di 2011-01-05 14:40:22.000000000 +0300
@@ -0,0 +1,17 @@
+module ldc.llvmasm;
+
+struct __asmtuple_t(T...)
+{
+ T v;
+}
+
+pragma(llvm_inline_asm)
+{
+ void __asm( )(char[] asmcode, char[] constraints, ...);
+ T __asm(T)(char[] asmcode, char[] constraints, ...);
+
+ template __asmtuple(T...)
+ {
+ __asmtuple_t!(T) __asmtuple(char[] asmcode, char[] constraints, ...);
+ }
+}
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/import/object.di druntime/import/object.di
--- druntime-orig/import/object.di 2010-12-16 01:43:28.000000000 +0300
+++ druntime/import/object.di 2011-01-05 14:40:22.000000000 +0300
@@ -142,7 +142,7 @@
// 32: // has typeinfo member
void* deallocator;
OffsetTypeInfo[] m_offTi;
- void* defaultConstructor;
+ void function(Object) defaultConstructor; // default Constructor
const(MemberInfo[]) function(string) xgetMembers;
static TypeInfo_Class find(in char[] classname);
@@ -298,7 +298,6 @@
interface TraceInfo
{
int opApply(scope int delegate(ref char[]));
- string toString();
}
string msg;
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/import/std/intrinsic.di druntime/import/std/intrinsic.di
--- druntime-orig/import/std/intrinsic.di 2010-12-15 10:30:54.000000000 +0300
+++ druntime/import/std/intrinsic.di 2011-01-05 18:03:08.459062852 +0300
@@ -1,171 +1,72 @@
-/**
- * These functions are built-in intrinsics to the compiler.
- *
- * Intrinsic functions are functions built in to the compiler, usually to take
- * advantage of specific CPU features that are inefficient to handle via
- * external functions. The compiler's optimizer and code generator are fully
- * integrated in with intrinsic functions, bringing to bear their full power on
- * them. This can result in some surprising speedups.
- *
- * Copyright: Public Domain
- * License: Public Domain
- * Authors: Walter Bright
- */
-module std.intrinsic;
-
-nothrow:
-
-/**
- * Scans the bits in v starting with bit 0, looking
- * for the first set bit.
- * Returns:
- * The bit number of the first bit set.
- * The return value is undefined if v is zero.
- */
-pure int bsf(size_t v);
-
-/**
- * Scans the bits in v from the most significant bit
- * to the least significant bit, looking
- * for the first set bit.
- * Returns:
- * The bit number of the first bit set.
- * The return value is undefined if v is zero.
- * Example:
- * ---
- * import std.stdio;
- * import std.intrinsic;
- *
- * int main()
- * {
- * uint v;
- * int x;
- *
- * v = 0x21;
- * x = bsf(v);
- * writefln("bsf(x%x) = %d", v, x);
- * x = bsr(v);
- * writefln("bsr(x%x) = %d", v, x);
- * return 0;
- * }
- * ---
- * Output:
- * bsf(x21) = 0
- * bsr(x21) = 5
- */
-pure int bsr(size_t v);
-
-/**
- * Tests the bit.
- */
-pure int bt(in size_t* p, size_t bitnum);
-
-/**
- * Tests and complements the bit.
- */
-int btc(size_t* p, size_t bitnum);
-
-/**
- * Tests and resets (sets to 0) the bit.
- */
-int btr(size_t* p, size_t bitnum);
-
-/**
- * Tests and sets the bit.
- * Params:
- * p = a non-NULL pointer to an array of size_ts.
- * index = a bit number, starting with bit 0 of p[0],
- * and progressing. It addresses bits like the expression:
----
-p[index / (size_t.sizeof*8)] & (1 << (index & ((size_t.sizeof*8) - 1)))
----
- * Returns:
- * A non-zero value if the bit was set, and a zero
- * if it was clear.
- *
- * Example:
- * ---
-import std.stdio;
-import std.intrinsic;
-
-int main()
-{
- size_t array[2];
-
- array[0] = 2;
- array[1] = 0x100;
-
- writefln("btc(array, 35) = %d", btc(array, 35));
- writefln("array = [0]:x%x, [1]:x%x", array[0], array[1]);
-
- writefln("btc(array, 35) = %d", btc(array, 35));
- writefln("array = [0]:x%x, [1]:x%x", array[0], array[1]);
-
- writefln("bts(array, 35) = %d", bts(array, 35));
- writefln("array = [0]:x%x, [1]:x%x", array[0], array[1]);
-
- writefln("btr(array, 35) = %d", btr(array, 35));
- writefln("array = [0]:x%x, [1]:x%x", array[0], array[1]);
-
- writefln("bt(array, 1) = %d", bt(array, 1));
- writefln("array = [0]:x%x, [1]:x%x", array[0], array[1]);
-
- return 0;
-}
- * ---
- * Output:
-
-btc(array, 35) = 0
-array = [0]:x2, [1]:x108
-btc(array, 35) = -1
-array = [0]:x2, [1]:x100
-bts(array, 35) = 0
-array = [0]:x2, [1]:x108
-btr(array, 35) = -1
-array = [0]:x2, [1]:x100
-bt(array, 1) = -1
-array = [0]:x2, [1]:x100
-
- */
-int bts(size_t* p, size_t bitnum);
-
-/**
- * Swaps bytes in a 4 byte uint end-to-end, i.e. byte 0 becomes
- * byte 3, byte 1 becomes byte 2, byte 2 becomes byte 1, byte 3
- * becomes byte 0.
- */
-pure uint bswap(uint v);
-
-
-/**
- * Reads I/O port at port_address.
- */
-ubyte inp(uint port_address);
-
-/**
- * ditto
- */
-ushort inpw(uint port_address);
-
-/**
- * ditto
- */
-uint inpl(uint port_address);
-
-
-/**
- * Writes and returns value to I/O port at port_address.
- */
-ubyte outp(uint port_address, ubyte value);
-
-/**
- * ditto
- */
-ushort outpw(uint port_address, ushort value);
-
-/**
- * ditto
- */
-uint outpl(uint port_address, uint value);
-
-
+// D import file generated from 'src/std/intrinsic.d'
+module std.intrinsic;
+version (LDC)
+{
+}
+else
+{
+ static assert(false,"This module is only valid for LDC");
+}
+nothrow
+{
+ pure int bsf(size_t v);
+
+ pure int bsr(size_t v);
+
+ pure int bt(in size_t* p, size_t bitnum)
+{
+return p[bitnum / ((uint).sizeof * 8)] & 1 << (bitnum & (uint).sizeof * 8 - 1) ? -1 : 0;
+}
+
+ int btc(size_t* p, size_t bitnum)
+{
+uint* q = p + bitnum / ((uint).sizeof * 8);
+uint mask = 1 << (bitnum & (uint).sizeof * 8 - 1);
+int result = *q & mask;
+*q ^= mask;
+return result ? -1 : 0;
+}
+ int btr(size_t* p, size_t bitnum)
+{
+uint* q = p + bitnum / ((uint).sizeof * 8);
+uint mask = 1 << (bitnum & (uint).sizeof * 8 - 1);
+int result = *q & mask;
+*q &= ~mask;
+return result ? -1 : 0;
+}
+ int bts(size_t* p, size_t bitnum)
+{
+uint* q = p + bitnum / ((uint).sizeof * 8);
+uint mask = 1 << (bitnum & (uint).sizeof * 8 - 1);
+int result = *q & mask;
+*q |= mask;
+return result ? -1 : 0;
+}
+ pure pragma (intrinsic, "llvm.bswap.i32")uint bswap(uint val);
+
+
+ ubyte inp(uint port_address)
+{
+assert(false && "inp intrinsic not yet implemented");
+}
+ ushort inpw(uint port_address)
+{
+assert(false && "inpw intrinsic not yet implemented");
+}
+ uint inpl(uint port_address)
+{
+assert(false && "inpl intrinsic not yet implemented");
+}
+ ubyte outp(uint port_address, ubyte value)
+{
+assert(false && "outp intrinsic not yet implemented");
+}
+ ushort outpw(uint port_address, ushort value)
+{
+assert(false && "outpw intrinsic not yet implemented");
+}
+ uint outpl(uint port_address, uint value)
+{
+assert(false && "outpl intrinsic not yet implemented");
+}
+}
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/core/atomic.d druntime/src/core/atomic.d
--- druntime-orig/src/core/atomic.d 2010-12-15 22:30:58.000000000 +0300
+++ druntime/src/core/atomic.d 2011-01-05 14:40:22.000000000 +0300
@@ -91,6 +91,117 @@
return false;
}
}
+
+////////////////////////////////////////////////////////////////////////////////
+// LDC Atomics Implementation
+////////////////////////////////////////////////////////////////////////////////
+
+else version( LDC )
+{
+ import ldc.intrinsics;
+
+ T atomicOp(string op, T, V1)( ref shared T val, V1 mod )
+ if( is( NakedType!(V1) == NakedType!(T) ) )
+ {
+ // binary operators
+ //
+ // + - * / % ^^ &
+ // | ^ << >> >>> ~ in
+ // == != < <= > >=
+ static if( op == "+" || op == "-" || op == "*" || op == "/" ||
+ op == "%" || op == "^^" || op == "&" || op == "|" ||
+ op == "^" || op == "<<" || op == ">>" || op == ">>>" ||
+ op == "~" || // skip "in"
+ op == "==" || op == "!=" || op == "<" || op == "<=" ||
+ op == ">" || op == ">=" )
+ {
+ T get = val; // compiler can do atomic load
+ mixin( "return get " ~ op ~ " mod;" );
+ }
+ else
+ // assignment operators
+ //
+ // += -= *= /= %= ^^= &=
+ // |= ^= <<= >>= >>>= ~=
+ static if( op == "+=" || op == "-=" || op == "*=" || op == "/=" ||
+ op == "%=" || op == "^^=" || op == "&=" || op == "|=" ||
+ op == "^=" || op == "<<=" || op == ">>=" || op == ">>>=" ) // skip "~="
+ {
+ T get, set;
+
+ do
+ {
+ get = set = atomicLoad!(msync.raw)( val );
+ mixin( "set " ~ op ~ " mod;" );
+ } while( !cas( &val, get, set ) );
+ return set;
+ }
+ else
+ {
+ static assert( false, "Operation not supported." );
+ }
+ }
+
+ bool cas(T,V1,V2)( shared(T)* here, const V1 ifThis, const V2 writeThis )
+ if( is( NakedType!(V1) == NakedType!(T) ) &&
+ is( NakedType!(V2) == NakedType!(T) ) )
+
+ {
+ T oldval = void;
+ static if (is(T P == U*, U))
+ {
+ oldval = cast(T)llvm_atomic_cmp_swap!(size_t)(cast(shared size_t*)&writeThis, cast(size_t)ifThis, cast(size_t)here);
+ }
+ else static if (is(T == bool))
+ {
+ oldval = llvm_atomic_cmp_swap!(ubyte)(cast(shared ubyte*)&writeThis, ifThis?1:0, here?1:0)?0:1;
+ }
+ else
+ {
+ oldval = llvm_atomic_cmp_swap!(T)(here, ifThis, writeThis);
+ }
+ return oldval == ifThis;
+ }
+
+
+ private
+ {
+ enum msync
+ {
+ raw, /// not sequenced
+ acq, /// hoist-load + hoist-store barrier
+ rel, /// sink-load + sink-store barrier
+ seq, /// fully sequenced (acq + rel)
+ }
+
+ T atomicLoad(msync ms = msync.seq, T)( const ref shared T val )
+ {
+ llvm_memory_barrier(
+ ms == msync.acq || ms == msync.seq,
+ ms == msync.acq || ms == msync.seq,
+ ms == msync.rel || ms == msync.seq,
+ ms == msync.rel || ms == msync.seq,
+ false);
+ static if (is(T P == U*, U)) // pointer
+ {
+ 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);
+ }
+ }
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// x86_32 Atomic Function Implementation
+////////////////////////////////////////////////////////////////////////////////
+
else version( AsmX86_32 )
{
T atomicOp(string op, T, V1)( ref shared T val, V1 mod )
@@ -398,6 +509,12 @@
}
}
}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// x86_64 Atomic Function Implementation
+////////////////////////////////////////////////////////////////////////////////
+
else version( AsmX86_64 )
{
T atomicOp(string op, T, V1)( ref shared T val, V1 mod )
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/core/stdc/math.d druntime/src/core/stdc/math.d
--- druntime-orig/src/core/stdc/math.d 2010-12-15 10:30:50.000000000 +0300
+++ druntime/src/core/stdc/math.d 2011-01-05 14:40:22.000000000 +0300
@@ -18,6 +18,7 @@
extern (C):
nothrow:
+pure: // LDC
alias float float_t;
alias double double_t;
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/core/stdc/stdarg.d druntime/src/core/stdc/stdarg.d
--- druntime-orig/src/core/stdc/stdarg.d 2010-12-15 10:30:50.000000000 +0300
+++ druntime/src/core/stdc/stdarg.d 2011-01-05 16:38:59.387062854 +0300
@@ -16,7 +16,69 @@
@system:
-version( X86 )
+version( LDC )
+{
+ /*********************
+ * The argument pointer type.
+ */
+ alias void* va_list;
+
+ /**********
+ * Initialize ap.
+ * Parmn should be the last named parameter.
+ */
+ pragma(va_start)
+ void va_start(T)(va_list ap, ref T);
+
+ /************
+ * Retrieve and return the next value that is type T.
+ * Should use the other va_arg instead, as this won't work for 64 bit code.
+ */
+ T va_arg(T)(ref va_list ap)
+ {
+ T arg = *cast(T*) ap;
+ ap = cast(va_list)( cast(void*) ap + ( ( T.sizeof + size_t.sizeof - 1 ) & ~( size_t.sizeof - 1 ) ) );
+ return arg;
+ }
+
+ /************
+ * Retrieve and return the next value that is type T.
+ * This is the preferred version.
+ */
+ void va_arg(T)(ref va_list ap, ref T parmn)
+ {
+ parmn = *cast(T*)ap;
+ ap = cast(va_list)(cast(void*)ap + ((T.sizeof + size_t.sizeof - 1) & ~(size_t.sizeof - 1)));
+ }
+
+ /*************
+ * Retrieve and store through parmn the next value that is of TypeInfo ti.
+ * Used when the static type is not known.
+ */
+ void va_arg()(ref va_list ap, TypeInfo ti, void* parmn)
+ {
+ // Wait until everyone updates to get TypeInfo.talign()
+ //auto talign = ti.talign();
+ //auto p = cast(void*)(cast(size_t)ap + talign - 1) & ~(talign - 1);
+ auto p = ap;
+ auto tsize = ti.tsize();
+ ap = cast(void*)(cast(size_t)p + ((tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1)));
+ parmn[0..tsize] = p[0..tsize];
+ }
+
+ /***********************
+ * End use of ap.
+ */
+ void va_end(va_list ap)
+ {
+ }
+
+ void va_copy(out va_list dest, va_list src)
+ {
+ dest = src;
+ }
+}
+else version( X86 )
{
/*********************
* The argument pointer type.
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/core/stdc/stdlib.d druntime/src/core/stdc/stdlib.d
--- druntime-orig/src/core/stdc/stdlib.d 2010-12-15 10:30:50.000000000 +0300
+++ druntime/src/core/stdc/stdlib.d 2011-01-05 14:40:22.000000000 +0300
@@ -93,3 +93,13 @@
{
void* alloca(size_t size); // non-standard
}
+else version( LDC )
+{
+ pragma(alloca)
+ void* alloca(size_t size);
+}
+else version( GNU )
+{
+ private import gcc.builtins;
+ alias gcc.builtins.__builtin_alloca alloca;
+}
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/core/vararg.d druntime/src/core/vararg.d
--- druntime-orig/src/core/vararg.d 2010-12-15 10:30:52.000000000 +0300
+++ druntime/src/core/vararg.d 2011-01-05 14:42:18.000000000 +0300
@@ -32,10 +32,22 @@
* paramn = The identifier of the rightmost parameter in the function
* parameter list.
*/
+version(LDC)
+{
+
+pragma(va_start)
+ void va_start(T)(va_list ap, ref T);
+
+}
+else
+{
+
void va_start(T)( out va_list ap, ref T parmn )
{
ap = cast(va_list)( cast(void*) &parmn + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) );
}
+
+}
/**
* This function returns the next argument in the sequence referenced by
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/gc/gcbits.d druntime/src/gc/gcbits.d
--- druntime-orig/src/gc/gcbits.d 2010-12-15 10:30:52.000000000 +0300
+++ druntime/src/gc/gcbits.d 2011-01-05 14:40:22.000000000 +0300
@@ -27,6 +27,10 @@
{
version = bitops;
}
+else version (LDC)
+{
+ version = bitops;
+}
else version (GNU)
{
// use the unoptimized version
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/gc/gcx.d druntime/src/gc/gcx.d
--- druntime-orig/src/gc/gcx.d 2010-12-15 10:30:52.000000000 +0300
+++ druntime/src/gc/gcx.d 2011-01-05 14:40:22.000000000 +0300
@@ -1465,7 +1465,8 @@
void initialize()
- { int dummy;
+ {
+ int dummy;
(cast(byte*)&this)[0 .. Gcx.sizeof] = 0;
stackBottom = cast(char*)&dummy;
@@ -2201,7 +2202,7 @@
if ((cast(size_t)p & ~(PAGESIZE-1)) == pcache)
continue;
- auto pool = findPool(p);
+ auto pool = findPool(p);
if (pool)
{
size_t offset = cast(size_t)(p - pool.baseAddr);
@@ -2271,80 +2272,129 @@
__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 version (X86_64)
+ {
+ ulong rax,rbx,rcx,rdx,rbp,rsi,rdi,r8,r9,r10,r11,r12,r13,r14,r15;
+ asm
+ {
+ movq rax[RBP], RAX ;
+ movq rbx[RBP], RBX ;
+ movq rcx[RBP], RCX ;
+ movq rdx[RBP], RDX ;
+ movq rbp[RBP], RBP ;
+ movq rsi[RBP], RSI ;
+ movq rdi[RBP], RDI ;
+ movq r8 [RBP], R8 ;
+ movq r9 [RBP], R9 ;
+ movq r10[RBP], R10 ;
+ movq r11[RBP], R11 ;
+ movq r12[RBP], R12 ;
+ movq r13[RBP], R13 ;
+ movq r14[RBP], R14 ;
+ movq r15[RBP], R15 ;
+ movq sp[RBP], RSP ;
+ }
+ }
+ else
+ {
+ static assert( false, "Architecture not supported." );
+ }
+ }
else version( D_InlineAsm_X86 )
{
- asm
- {
- pushad ;
- mov sp[EBP],ESP ;
- }
+ asm
+ {
+ pushad ;
+ mov sp[EBP],ESP ;
+ }
+ }
+ else version ( D_InlineAsm_X86_64 )
+ {
+ asm
+ {
+ push RAX ;
+ push RBX ;
+ push RCX ;
+ push RDX ;
+ push RSI ;
+ push RDI ;
+ push RBP ;
+ push R8 ;
+ push R9 ;
+ push R10 ;
+ push R11 ;
+ push R12 ;
+ push R13 ;
+ push R14 ;
+ push R15 ;
+ push EAX ; // 16 byte align the stack
+ }
+ }
+ else
+ {
+ static assert( false, "Architecture not supported." );
}
- else version ( D_InlineAsm_X86_64 )
- {
- asm
- {
- push RAX ;
- push RBX ;
- push RCX ;
- push RDX ;
- push RSI ;
- push RDI ;
- push RBP ;
- push R8 ;
- push R9 ;
- push R10 ;
- push R11 ;
- push R12 ;
- push R13 ;
- push R14 ;
- push R15 ;
- push EAX ; // 16 byte align the stack
- }
- }
- else
- {
- static assert( false, "Architecture not supported." );
- }
result = fullcollect(sp);
- version( GNU )
- {
- // registers will be popped automatically
- }
- else version( D_InlineAsm_X86 )
- {
- asm
- {
- popad;
- }
- }
- else version ( D_InlineAsm_X86_64 )
- {
- asm
- {
- pop EAX ; // 16 byte align the stack
- pop R15 ;
- pop R14 ;
- pop R13 ;
- pop R12 ;
- pop R11 ;
- pop R10 ;
- pop R9 ;
- pop R8 ;
- pop RBP ;
- pop RDI ;
- pop RSI ;
- pop RDX ;
- pop RCX ;
- pop RBX ;
- pop RAX ;
- }
- }
- else
- {
- static assert( false, "Architecture not supported." );
- }
+ version( GNU )
+ {
+ // registers will be popped automatically
+ }
+ else version(LDC)
+ {
+ // nothing to do
+ }
+ else version( D_InlineAsm_X86 )
+ {
+ asm
+ {
+ popad;
+ }
+ }
+ else version ( D_InlineAsm_X86_64 )
+ {
+ asm
+ {
+ pop EAX ; // 16 byte align the stack
+ pop R15 ;
+ pop R14 ;
+ pop R13 ;
+ pop R12 ;
+ pop R11 ;
+ pop R10 ;
+ pop R9 ;
+ pop R8 ;
+ pop RBP ;
+ pop RDI ;
+ pop RSI ;
+ pop RDX ;
+ pop RCX ;
+ pop RBX ;
+ pop RAX ;
+ }
+ }
+ else
+ {
+ static assert( false, "Architecture not supported." );
+ }
return result;
}
@@ -2358,7 +2408,7 @@
Pool* pool;
debug(COLLECT_PRINTF) printf("Gcx.fullcollect()\n");
- //printf("\tpool address range = %p .. %p\n", minAddr, maxAddr);
+ //printf("\tpool address range = %p .. %p\n", minAddr, maxAddr);
thread_suspendAll();
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/object_.d druntime/src/object_.d
--- druntime-orig/src/object_.d 2010-12-16 01:43:28.000000000 +0300
+++ druntime/src/object_.d 2011-01-05 14:40:22.000000000 +0300
@@ -1763,7 +1763,6 @@
{
int len = 0;
ModuleReference *mr;
-
for (mr = _Dmodule_ref; mr; mr = mr.next)
len++;
_moduleinfo_array = new ModuleInfo*[len];
@@ -2278,7 +2277,6 @@
_d_monitor_create(h);
m = getMonitor(h);
}
-
IMonitor i = m.impl;
if (i is null)
@@ -2377,7 +2375,7 @@
size_t _aaLen(void* p);
void* _aaGet(void** pp, TypeInfo keyti, size_t valuesize, ...);
void* _aaGetRvalue(void* p, TypeInfo keyti, size_t valuesize, ...);
- void* _aaIn(void* p, TypeInfo keyti);
+ void* _aaIn(void* p, TypeInfo keyti, ...);
void _aaDel(void* p, TypeInfo keyti, ...);
void[] _aaValues(void* p, size_t keysize, size_t valuesize);
void[] _aaKeys(void* p, size_t keysize, size_t valuesize);
@@ -2422,7 +2420,7 @@
return *cast(Key[]*) &a;
}
- int opApply(scope int delegate(ref Key, ref Value) dg)
+ int opApply(scope int delegate(ref Key, ref const Value) dg)
{
return _aaApply2(p, aligntsize(Key.sizeof), cast(_dg2_t)dg);
}
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/rt/adi.d druntime/src/rt/adi.d
--- druntime-orig/src/rt/adi.d 2010-12-15 10:30:48.000000000 +0300
+++ druntime/src/rt/adi.d 2011-01-05 15:13:25.247062853 +0300
@@ -36,6 +36,8 @@
extern (C) void gc_free( void* p );
}
+version (DMD) version (X86)
+ version = DMD_X86;
struct Array
{
@@ -49,7 +51,7 @@
* reversed.
*/
-extern (C) long _adReverseChar(char[] a)
+extern (C) char[] _adReverseChar(char[] a)
{
if (a.length > 1)
{
@@ -109,7 +111,7 @@
hi = hi - 1 + (stridehi - stridelo);
}
}
- return *cast(long*)(&a);
+ return *cast(char[]*)&a;
}
unittest
@@ -226,7 +228,7 @@
* Support for array.reverse property.
*/
-extern (C) void[] _adReverse(Array a, size_t szelem)
+extern (C) void[] _adReverse(void[] a, size_t szelem)
out (result)
{
assert(result is *cast(void[]*)(&a));
@@ -358,7 +360,7 @@
* 0 not equal
*/
-extern (C) int _adEq(Array a1, Array a2, TypeInfo ti)
+extern (C) int _adEq(void[] a1, void[] a2, TypeInfo ti)
{
debug(adi) printf("_adEq(a1.length = %d, a2.length = %d)\n", a1.length, a2.length);
if (a1.length != a2.length)
@@ -379,7 +381,7 @@
return 1; // equal
}
-extern (C) int _adEq2(Array a1, Array a2, TypeInfo ti)
+extern (C) int _adEq2(void[] a1, void[] a2, TypeInfo ti)
{
debug(adi) printf("_adEq2(a1.length = %d, a2.length = %d)\n", a1.length, a2.length);
if (a1.length != a2.length)
@@ -405,7 +407,7 @@
* Support for array compare test.
*/
-extern (C) int _adCmp(Array a1, Array a2, TypeInfo ti)
+extern (C) int _adCmp(void[] a1, void[] a2, TypeInfo ti)
{
debug(adi) printf("adCmp()\n");
auto len = a1.length;
@@ -435,7 +437,7 @@
return (a1.length > a2.length) ? 1 : -1;
}
-extern (C) int _adCmp2(Array a1, Array a2, TypeInfo ti)
+extern (C) int _adCmp2(void[] a1, void[] a2, TypeInfo ti)
{
debug(adi) printf("_adCmp2(a1.length = %d, a2.length = %d)\n", a1.length, a2.length);
return ti.compare(&a1, &a2);
@@ -461,9 +463,9 @@
* Support for array compare test.
*/
-extern (C) int _adCmpChar(Array a1, Array a2)
+extern (C) int _adCmpChar(void[] a1, void[] a2)
{
- version (X86)
+ version (DMD_X86)
{
asm
{ naked ;
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/rt/alloca.d druntime/src/rt/alloca.d
--- druntime-orig/src/rt/alloca.d 2010-12-15 10:30:48.000000000 +0300
+++ druntime/src/rt/alloca.d 2011-01-05 14:54:45.903062853 +0300
@@ -52,16 +52,16 @@
{
asm
{
- add EAX,15 ;
- and EAX,0xFFFFFFF0 ; // round up to 16 byte boundary
+ add EAX,15 ;
+ and EAX,0xFFFFFFF0 ; // round up to 16 byte boundary
}
}
else
{
asm
{
- add EAX,3 ;
- and EAX,0xFFFFFFFC ; // round up to dword
+ add EAX,3 ;
+ and EAX,0xFFFFFFFC ; // round up to dword
}
}
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/rt/arrayInit.d druntime/src/rt/arrayInit.d
--- druntime-orig/src/rt/arrayInit.d 1970-01-01 03:00:00.000000000 +0300
+++ druntime/src/rt/arrayInit.d 2011-01-05 14:40:22.000000000 +0300
@@ -0,0 +1,150 @@
+private import ldc.intrinsics;
+
+extern(C):
+
+int memcmp(void*,void*,size_t);
+size_t strlen(char*);
+
+// per-element array init routines
+
+void _d_array_init_i16(ushort* a, size_t n, ushort v)
+{
+ auto p = a;
+ auto end = a+n;
+ while (p !is end)
+ *p++ = v;
+}
+
+void _d_array_init_i32(uint* a, size_t n, uint v)
+{
+ auto p = a;
+ auto end = a+n;
+ while (p !is end)
+ *p++ = v;
+}
+
+void _d_array_init_i64(ulong* a, size_t n, ulong v)
+{
+ auto p = a;
+ auto end = a+n;
+ while (p !is end)
+ *p++ = v;
+}
+
+void _d_array_init_float(float* a, size_t n, float v)
+{
+ auto p = a;
+ auto end = a+n;
+ while (p !is end)
+ *p++ = v;
+}
+
+void _d_array_init_double(double* a, size_t n, double v)
+{
+ auto p = a;
+ auto end = a+n;
+ while (p !is end)
+ *p++ = v;
+}
+
+void _d_array_init_real(real* a, size_t n, real v)
+{
+ auto p = a;
+ auto end = a+n;
+ while (p !is end)
+ *p++ = v;
+}
+
+void _d_array_init_cfloat(cfloat* a, size_t n, cfloat v)
+{
+ auto p = a;
+ auto end = a+n;
+ while (p !is end)
+ *p++ = v;
+}
+
+void _d_array_init_cdouble(cdouble* a, size_t n, cdouble v)
+{
+ auto p = a;
+ auto end = a+n;
+ while (p !is end)
+ *p++ = v;
+}
+
+void _d_array_init_creal(creal* a, size_t n, creal v)
+{
+ auto p = a;
+ auto end = a+n;
+ while (p !is end)
+ *p++ = v;
+}
+
+void _d_array_init_pointer(void** a, size_t n, void* v)
+{
+ auto p = a;
+ auto end = a+n;
+ while (p !is end)
+ *p++ = v;
+}
+
+void _d_array_init_mem(void* a, size_t na, void* v, size_t nv)
+{
+ auto p = a;
+ auto end = a + na*nv;
+ while (p !is end) {
+ llvm_memcpy(p,v,nv,0);
+ p += nv;
+ }
+}
+
+/*
+void _d_array_init(TypeInfo ti, void* a)
+{
+ auto initializer = ti.next.init();
+ auto isize = initializer.length;
+ auto q = initializer.ptr;
+
+ if (isize == 1)
+ memset(p, *cast(ubyte*)q, size);
+ else if (isize == int.sizeof)
+ {
+ int init = *cast(int*)q;
+ size /= int.sizeof;
+ for (size_t u = 0; u < size; u++)
+ {
+ (cast(int*)p)[u] = init;
+ }
+ }
+ else
+ {
+ for (size_t u = 0; u < size; u += isize)
+ {
+ memcpy(p + u, q, isize);
+ }
+ }
+}*/
+
+// for array cast
+size_t _d_array_cast_len(size_t len, size_t elemsz, size_t newelemsz)
+{
+ if (newelemsz == 1) {
+ return len*elemsz;
+ }
+ else if ((len*elemsz) % newelemsz) {
+ throw new Exception("Bad array cast");
+ }
+ return (len*elemsz)/newelemsz;
+}
+
+// slice copy when assertions are enabled
+void _d_array_slice_copy(void* dst, size_t dstlen, void* src, size_t srclen)
+{
+ if (dstlen != 0) assert(dst);
+ if (dstlen != 0) assert(src);
+ if (dstlen != srclen)
+ throw new Exception("lengths don't match for array copy");
+ else if (dst+dstlen <= src || src+srclen <= dst)
+ llvm_memcpy!size_t(dst, src, dstlen, 0);
+ else
+ throw new Exception("overlapping array copy");
+}
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/rt/dmain2.d druntime/src/rt/dmain2.d
--- druntime-orig/src/rt/dmain2.d 2010-12-15 10:30:48.000000000 +0300
+++ druntime/src/rt/dmain2.d 2011-01-05 14:40:22.000000000 +0300
@@ -39,6 +39,8 @@
pragma(lib, "shell32.lib"); // needed for CommandLineToArgvW
}
+extern (C) Throwable.TraceInfo _d_traceContext(void* ptr = null); // LDC
+
version (all)
{
Throwable _d_unhandled = null;
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/rt/ldc_eh.d druntime/src/rt/ldc_eh.d
--- druntime-orig/src/rt/ldc_eh.d 1970-01-01 03:00:00.000000000 +0300
+++ druntime/src/rt/ldc_eh.d 2011-01-05 14:40:22.000000000 +0300
@@ -0,0 +1,428 @@
+/**
+ * This module contains functions and structures required for
+ * exception handling.
+ */
+module ldc_eh;
+
+private import core.stdc.stdio;
+private import core.stdc.stdlib;
+private import rt.util.console;
+private import core.vararg;
+
+// debug = EH_personality;
+// debug = EH_personality_verbose;
+
+// current EH implementation works on x86
+// if it has a working unwind runtime
+version(X86) {
+ version(linux) version=X86_UNWIND;
+ version(darwin) version=X86_UNWIND;
+ version(solaris) version=X86_UNWIND;
+}
+version(X86_64) {
+ version(linux) version=X86_UNWIND;
+ version(darwin) version=X86_UNWIND;
+ version(solaris) version=X86_UNWIND;
+}
+
+//version = HP_LIBUNWIND;
+
+// D runtime functions
+extern(C) {
+ int _d_isbaseof(ClassInfo oc, ClassInfo c);
+}
+
+// libunwind headers
+extern(C)
+{
+ enum _Unwind_Reason_Code : int
+ {
+ NO_REASON = 0,
+ FOREIGN_EXCEPTION_CAUGHT = 1,
+ FATAL_PHASE2_ERROR = 2,
+ FATAL_PHASE1_ERROR = 3,
+ NORMAL_STOP = 4,
+ END_OF_STACK = 5,
+ HANDLER_FOUND = 6,
+ INSTALL_CONTEXT = 7,
+ CONTINUE_UNWIND = 8
+ }
+
+ enum _Unwind_Action : int
+ {
+ SEARCH_PHASE = 1,
+ CLEANUP_PHASE = 2,
+ HANDLER_FRAME = 4,
+ FORCE_UNWIND = 8
+ }
+
+ alias void* _Unwind_Context_Ptr;
+
+ alias void function(_Unwind_Reason_Code, _Unwind_Exception*) _Unwind_Exception_Cleanup_Fn;
+
+ struct _Unwind_Exception
+ {
+ ulong exception_class;
+ _Unwind_Exception_Cleanup_Fn exception_cleanup;
+ ptrdiff_t private_1;
+ ptrdiff_t private_2;
+ }
+
+// interface to HP's libunwind from http://www.nongnu.org/libunwind/
+version(HP_LIBUNWIND)
+{
+ void __libunwind_Unwind_Resume(_Unwind_Exception *);
+ _Unwind_Reason_Code __libunwind_Unwind_RaiseException(_Unwind_Exception *);
+ ptrdiff_t __libunwind_Unwind_GetLanguageSpecificData(_Unwind_Context_Ptr
+ context);
+ ptrdiff_t __libunwind_Unwind_GetIP(_Unwind_Context_Ptr context);
+ ptrdiff_t __libunwind_Unwind_SetIP(_Unwind_Context_Ptr context,
+ ptrdiff_t new_value);
+ ptrdiff_t __libunwind_Unwind_SetGR(_Unwind_Context_Ptr context, int index,
+ ptrdiff_t new_value);
+ ptrdiff_t __libunwind_Unwind_GetRegionStart(_Unwind_Context_Ptr context);
+
+ alias __libunwind_Unwind_Resume _Unwind_Resume;
+ alias __libunwind_Unwind_RaiseException _Unwind_RaiseException;
+ alias __libunwind_Unwind_GetLanguageSpecificData
+ _Unwind_GetLanguageSpecificData;
+ alias __libunwind_Unwind_GetIP _Unwind_GetIP;
+ alias __libunwind_Unwind_SetIP _Unwind_SetIP;
+ alias __libunwind_Unwind_SetGR _Unwind_SetGR;
+ alias __libunwind_Unwind_GetRegionStart _Unwind_GetRegionStart;
+}
+else version(X86_UNWIND)
+{
+ void _Unwind_Resume(_Unwind_Exception*);
+ _Unwind_Reason_Code _Unwind_RaiseException(_Unwind_Exception*);
+ ptrdiff_t _Unwind_GetLanguageSpecificData(_Unwind_Context_Ptr context);
+ ptrdiff_t _Unwind_GetIP(_Unwind_Context_Ptr context);
+ ptrdiff_t _Unwind_SetIP(_Unwind_Context_Ptr context, ptrdiff_t new_value);
+ ptrdiff_t _Unwind_SetGR(_Unwind_Context_Ptr context, int index,
+ ptrdiff_t new_value);
+ ptrdiff_t _Unwind_GetRegionStart(_Unwind_Context_Ptr context);
+}
+else
+{
+ // runtime calls these directly
+ void _Unwind_Resume(_Unwind_Exception*)
+ {
+ console("_Unwind_Resume is not implemented on this platform.\n");
+ }
+ _Unwind_Reason_Code _Unwind_RaiseException(_Unwind_Exception*)
+ {
+ console("_Unwind_RaiseException is not implemented on this platform.\n");
+ return _Unwind_Reason_Code.FATAL_PHASE1_ERROR;
+ }
+}
+
+}
+
+// error and exit
+extern(C) private void fatalerror(in char* format, ...)
+{
+ va_list args;
+ va_start(args, format);
+ printf("Fatal error in EH code: ");
+ vprintf(format, args);
+ printf("\n");
+ abort();
+}
+
+
+// helpers for reading certain DWARF data
+private ubyte* get_uleb128(ubyte* addr, ref size_t res)
+{
+ res = 0;
+ size_t bitsize = 0;
+
+ // read as long as high bit is set
+ while(*addr & 0x80) {
+ res |= (*addr & 0x7f) << bitsize;
+ bitsize += 7;
+ addr += 1;
+ if(bitsize >= size_t.sizeof*8)
+ fatalerror("tried to read uleb128 that exceeded size of size_t");
+ }
+ // read last
+ if(bitsize != 0 && *addr >= 1 << size_t.sizeof*8 - bitsize)
+ fatalerror("Fatal error in EH code: tried to read uleb128 that exceeded size of size_t");
+ res |= (*addr) << bitsize;
+
+ return addr + 1;
+}
+
+private ubyte* get_sleb128(ubyte* addr, ref ptrdiff_t res)
+{
+ res = 0;
+ size_t bitsize = 0;
+
+ // read as long as high bit is set
+ while(*addr & 0x80) {
+ res |= (*addr & 0x7f) << bitsize;
+ bitsize += 7;
+ addr += 1;
+ if(bitsize >= size_t.sizeof*8)
+ fatalerror("tried to read sleb128 that exceeded size of size_t");
+ }
+ // read last
+ if(bitsize != 0 && *addr >= 1 << size_t.sizeof*8 - bitsize)
+ fatalerror("tried to read sleb128 that exceeded size of size_t");
+ res |= (*addr) << bitsize;
+
+ // take care of sign
+ if(bitsize < size_t.sizeof*8 && ((*addr) & 0x40))
+ res |= cast(ptrdiff_t)(-1) ^ ((1 << (bitsize+7)) - 1);
+
+ return addr + 1;
+}
+
+
+// exception struct used by the runtime.
+// _d_throw allocates a new instance and passes the address of its
+// _Unwind_Exception member to the unwind call. The personality
+// routine is then able to get the whole struct by looking at the data
+// surrounding the unwind info.
+struct _d_exception
+{
+ Object exception_object;
+ _Unwind_Exception unwind_info;
+}
+
+// the 8-byte string identifying the type of exception
+// the first 4 are for vendor, the second 4 for language
+//TODO: This may be the wrong way around
+char[8] _d_exception_class = "LLDCD1\0\0";
+
+
+//
+// x86 unwind specific implementation of personality function
+// and helpers
+//
+version(X86_UNWIND)
+{
+
+// the personality routine gets called by the unwind handler and is responsible for
+// reading the EH tables and deciding what to do
+extern(C) _Unwind_Reason_Code _d_eh_personality(int ver, _Unwind_Action actions, ulong exception_class, _Unwind_Exception* exception_info, _Unwind_Context_Ptr context)
+{
+ debug(EH_personality_verbose) printf("entering personality function. context: %p\n", context);
+ // check ver: the C++ Itanium ABI only allows ver == 1
+ if(ver != 1)
+ return _Unwind_Reason_Code.FATAL_PHASE1_ERROR;
+
+ // check exceptionClass
+ //TODO: Treat foreign exceptions with more respect
+ if((cast(char*)&exception_class)[0..8] != _d_exception_class)
+ return _Unwind_Reason_Code.FATAL_PHASE1_ERROR;
+
+ // find call site table, action table and classinfo table
+ // Note: callsite and action tables do not contain static-length
+ // data and will be parsed as needed
+ // Note: classinfo_table points past the end of the table
+ ubyte* callsite_table;
+ ubyte* action_table;
+ ClassInfo* classinfo_table;
+ _d_getLanguageSpecificTables(context, callsite_table, action_table, classinfo_table);
+ if (callsite_table is null)
+ return _Unwind_Reason_Code.CONTINUE_UNWIND;
+
+ /*
+ find landing pad and action table index belonging to ip by walking
+ the callsite_table
+ */
+ ubyte* callsite_walker = callsite_table;
+
+ // get the instruction pointer
+ // will be used to find the right entry in the callsite_table
+ // -1 because it will point past the last instruction
+ ptrdiff_t ip = _Unwind_GetIP(context) - 1;
+
+ // address block_start is relative to
+ ptrdiff_t region_start = _Unwind_GetRegionStart(context);
+
+ // table entries
+ uint block_start_offset, block_size;
+ ptrdiff_t landing_pad;
+ size_t action_offset;
+
+ while(true) {
+ // if we've gone through the list and found nothing...
+ if(callsite_walker >= action_table)
+ return _Unwind_Reason_Code.CONTINUE_UNWIND;
+
+ block_start_offset = *cast(uint*)callsite_walker;
+ block_size = *(cast(uint*)callsite_walker + 1);
+ landing_pad = *(cast(uint*)callsite_walker + 2);
+ if(landing_pad)
+ landing_pad += region_start;
+ callsite_walker = get_uleb128(callsite_walker + 3*uint.sizeof, action_offset);
+
+ debug(EH_personality_verbose) printf("ip=%llx %d %d %llx\n", ip, block_start_offset, block_size, landing_pad);
+
+ // since the list is sorted, as soon as we're past the ip
+ // there's no handler to be found
+ if(ip < region_start + block_start_offset)
+ return _Unwind_Reason_Code.CONTINUE_UNWIND;
+
+ // if we've found our block, exit
+ if(ip < region_start + block_start_offset + block_size)
+ break;
+ }
+
+ debug(EH_personality) printf("Found correct landing pad and actionOffset %d\n", action_offset);
+
+ // now we need the exception's classinfo to find a handler
+ // the exception_info is actually a member of a larger _d_exception struct
+ // the runtime allocated. get that now
+ _d_exception* exception_struct = cast(_d_exception*)(cast(ubyte*)exception_info - _d_exception.unwind_info.offsetof);
+
+ // if there's no action offset and no landing pad, continue unwinding
+ if(!action_offset && !landing_pad)
+ return _Unwind_Reason_Code.CONTINUE_UNWIND;
+
+ // if there's no action offset but a landing pad, this is a cleanup handler
+ else if(!action_offset && landing_pad)
+ return _d_eh_install_finally_context(actions, landing_pad, exception_struct, context);
+
+ /*
+ walk action table chain, comparing classinfos using _d_isbaseof
+ */
+ ubyte* action_walker = action_table + action_offset - 1;
+
+ ptrdiff_t ti_offset, next_action_offset;
+ while(true) {
+ action_walker = get_sleb128(action_walker, ti_offset);
+ // it is intentional that we not modify action_walker here
+ // next_action_offset is from current action_walker position
+ get_sleb128(action_walker, next_action_offset);
+
+ // negative are 'filters' which we don't use
+ if(!(ti_offset >= 0))
+ fatalerror("Filter actions are unsupported");
+
+ // zero means cleanup, which we require to be the last action
+ if(ti_offset == 0) {
+ if(!(next_action_offset == 0))
+ fatalerror("Cleanup action must be last in chain");
+ return _d_eh_install_finally_context(actions, landing_pad, exception_struct, context);
+ }
+
+ // get classinfo for action and check if the one in the
+ // exception structure is a base
+ ClassInfo catch_ci = *(classinfo_table - ti_offset);
+ debug(EH_personality) printf("Comparing catch %s to exception %s\n", catch_ci.name.ptr, exception_struct.exception_object.classinfo.name.ptr);
+ if(_d_isbaseof(exception_struct.exception_object.classinfo, catch_ci))
+ return _d_eh_install_catch_context(actions, ti_offset, landing_pad, exception_struct, context);
+
+ // we've walked through all actions and found nothing...
+ if(next_action_offset == 0)
+ return _Unwind_Reason_Code.CONTINUE_UNWIND;
+ else
+ action_walker += next_action_offset;
+ }
+
+ fatalerror("reached unreachable");
+ return _Unwind_Reason_Code.FATAL_PHASE1_ERROR;
+}
+
+// These are the register numbers for SetGR that
+// llvm's eh.exception and eh.selector intrinsics
+// will pick up.
+// Hints for these can be found by looking at the
+// EH_RETURN_DATA_REGNO macro in GCC, careful testing
+// is required though.
+version (X86_64)
+{
+ private int eh_exception_regno = 0;
+ private int eh_selector_regno = 1;
+} else {
+ private int eh_exception_regno = 0;
+ private int eh_selector_regno = 2;
+}
+
+private _Unwind_Reason_Code _d_eh_install_catch_context(_Unwind_Action actions, ptrdiff_t switchval, ptrdiff_t landing_pad, _d_exception* exception_struct, _Unwind_Context_Ptr context)
+{
+ debug(EH_personality) printf("Found catch clause!\n");
+
+ if(actions & _Unwind_Action.SEARCH_PHASE)
+ return _Unwind_Reason_Code.HANDLER_FOUND;
+
+ else if(actions & _Unwind_Action.CLEANUP_PHASE)
+ {
+ debug(EH_personality) printf("Setting switch value to: %d!\n", switchval);
+ _Unwind_SetGR(context, eh_exception_regno, cast(ptrdiff_t)cast(void*)(exception_struct.exception_object));
+ _Unwind_SetGR(context, eh_selector_regno, cast(ptrdiff_t)switchval);
+ _Unwind_SetIP(context, landing_pad);
+ return _Unwind_Reason_Code.INSTALL_CONTEXT;
+ }
+
+ fatalerror("reached unreachable");
+ return _Unwind_Reason_Code.FATAL_PHASE2_ERROR;
+}
+
+private _Unwind_Reason_Code _d_eh_install_finally_context(_Unwind_Action actions, ptrdiff_t landing_pad, _d_exception* exception_struct, _Unwind_Context_Ptr context)
+{
+ // if we're merely in search phase, continue
+ if(actions & _Unwind_Action.SEARCH_PHASE)
+ return _Unwind_Reason_Code.CONTINUE_UNWIND;
+
+ debug(EH_personality) printf("Calling cleanup routine...\n");
+
+ _Unwind_SetGR(context, eh_exception_regno, cast(ptrdiff_t)exception_struct);
+ _Unwind_SetGR(context, eh_selector_regno, 0);
+ _Unwind_SetIP(context, landing_pad);
+ return _Unwind_Reason_Code.INSTALL_CONTEXT;
+}
+
+private void _d_getLanguageSpecificTables(_Unwind_Context_Ptr context, ref ubyte* callsite, ref ubyte* action, ref ClassInfo* ci)
+{
+ ubyte* data = cast(ubyte*)_Unwind_GetLanguageSpecificData(context);
+ if (data is null)
+ {
+ //printf("language specific data was null\n");
+ callsite = null;
+ action = null;
+ ci = null;
+ return;
+ }
+
+ //TODO: Do proper DWARF reading here
+ if(*data++ != 0xff)
+ fatalerror("DWARF header has unexpected format 1");
+
+ if(*data++ != 0x00)
+ fatalerror("DWARF header has unexpected format 2");
+ size_t cioffset;
+ data = get_uleb128(data, cioffset);
+ ci = cast(ClassInfo*)(data + cioffset);
+
+ if(*data++ != 0x03)
+ fatalerror("DWARF header has unexpected format 3");
+ size_t callsitelength;
+ data = get_uleb128(data, callsitelength);
+ action = data + callsitelength;
+
+ callsite = data;
+}
+
+} // end of x86 Linux specific implementation
+
+
+extern(C) void _d_throw_exception(Object e)
+{
+ if (e !is null)
+ {
+ _d_exception* exc_struct = new _d_exception;
+ exc_struct.unwind_info.exception_class = *cast(ulong*)_d_exception_class.ptr;
+ exc_struct.exception_object = e;
+ _Unwind_Reason_Code ret = _Unwind_RaiseException(&exc_struct.unwind_info);
+ console("_Unwind_RaiseException failed with reason code: ")(ret)("\n");
+ }
+ abort();
+}
+
+extern(C) void _d_eh_resume_unwind(_d_exception* exception_struct)
+{
+ _Unwind_Resume(&exception_struct.unwind_info);
+}
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/rt/lifetime.d druntime/src/rt/lifetime.d
--- druntime-orig/src/rt/lifetime.d 2010-12-15 10:30:48.000000000 +0300
+++ druntime/src/rt/lifetime.d 2011-01-05 17:33:37.155062853 +0300
@@ -89,6 +89,18 @@
return gc_malloc(sz);
}
+version (LDC)
+{
+
+/**
+ * for allocating a single POD value
+ */
+extern (C) void* _d_allocmemoryT(TypeInfo ti)
+{
+ return gc_malloc(ti.tsize(), !(ti.flags() & 1) ? BlkAttr.NO_SCAN : 0);
+}
+
+} // version (LDC)
/**
*
@@ -820,14 +832,22 @@
__setArrayAllocLength(info, allocsize, isshared);
auto p = __arrayStart(info)[0 .. dim];
- version(X86)
+ version(LDC)
+ {
+ va_list ap2;
+ va_copy(ap2, ap);
+ }
+ else version(X86)
{
va_list ap2;
va_copy(ap2, ap);
}
for (size_t i = 0; i < dim; i++)
{
- version(X86_64)
+ version(LDC)
+ {
+ }
+ else version(X86_64)
{
__va_list argsave = *cast(__va_list*)ap;
va_list ap2 = &argsave;
@@ -870,7 +890,9 @@
else
{
va_list q;
- version(X86)
+ version(LDC)
+ va_start(q, ndims);
+ else version(X86)
va_start(q, ndims);
else version(X86_64)
va_start(q, __va_argsave);
@@ -893,6 +915,8 @@
else
{
va_list q;
+ version(LDC)
+ va_start(q, ndims);
version(X86)
va_start(q, ndims);
else version(X86_64)
@@ -1597,6 +1621,20 @@
return newcap;
}
+version (LDC)
+{
+
+/**
+ * Appends a single element to an array.
+ */
+extern (C) void[] _d_arrayappendcT(TypeInfo ti, byte[] *x, byte *argp)
+{
+ return _d_arrayappendT(ti, cast(Array*)x, argp[0..1]);
+}
+
+}
+else
+{
/**
*
@@ -1622,6 +1660,7 @@
}
}
+}
/**
* Append dchar to char[]
@@ -1904,7 +1943,7 @@
/**
*
*/
-extern (C) void[] _adDupT(TypeInfo ti, Array2 a)
+extern (C) void[] _adDupT(TypeInfo ti, void[] a)
out (result)
{
auto sizeelem = ti.next.tsize(); // array element size
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/rt/memory.d druntime/src/rt/memory.d
--- druntime-orig/src/rt/memory.d 2010-12-15 10:30:48.000000000 +0300
+++ druntime/src/rt/memory.d 2011-01-05 14:40:22.000000000 +0300
@@ -13,6 +13,8 @@
*/
module rt.memory;
+version(DMD)
+{
private
{
@@ -240,3 +242,616 @@
static assert( false, "Operating system not supported." );
}
}
+
+}
+else version(LDC)
+{
+
+version = GC_Use_Dynamic_Ranges;
+
+version(darwin)
+{
+ version = GC_Use_Data_Dyld;
+ version = GC_Use_Dynamic_Ranges;
+ import core.stdc.config : c_ulong;
+}
+else version(Posix)
+{
+ version = GC_Use_Data_Proc_Maps;
+}
+else version(solaris)
+{
+ version = GC_Use_Data_Proc_Maps;
+}
+else version(freebsd)
+{
+ version = GC_Use_Data_Proc_Maps;
+}
+
+
+version(GC_Use_Data_Proc_Maps)
+{
+ version(Posix) {} else {
+ static assert(false, "Proc Maps only supported on Posix systems");
+ }
+ import core.stdc.string : memmove;
+ import core.sys.posix.fcntl : open, O_RDONLY;
+ import core.sys.posix.unistd : close, read;
+
+ version = GC_Use_Dynamic_Ranges;
+}
+
+private
+{
+ version( linux )
+ {
+ //version = SimpleLibcStackEnd;
+
+ version( SimpleLibcStackEnd )
+ {
+ extern (C) extern void* __libc_stack_end;
+ }
+ else
+ {
+ import core.sys.posix.dlfcn;
+ }
+ }
+ else version(freebsd)
+ {
+ //version = SimpleLibcStackEnd;
+
+ version( SimpleLibcStackEnd )
+ {
+ extern (C) extern void* __libc_stack_end;
+ }
+ else
+ {
+ import core.sys.posix.dlfcn;
+ }
+ }
+ pragma(intrinsic, "llvm.frameaddress")
+ {
+ void* llvm_frameaddress(uint level=0);
+ }
+ extern (C) void gc_addRange( void* p, size_t sz );
+ extern (C) void gc_removeRange( void* p );
+}
+
+
+/**
+ *
+ */
+
+version( solaris ) {
+ version(X86_64) {
+ extern (C) void* _userlimit;
+ }
+}
+
+extern (C) void* rt_stackBottom()
+{
+ version( Win32 )
+ {
+ void* bottom;
+ asm
+ {
+ mov EAX, FS:4;
+ mov bottom, EAX;
+ }
+ return bottom;
+ }
+ else version( linux )
+ {
+ version( SimpleLibcStackEnd )
+ {
+ return __libc_stack_end;
+ }
+ else
+ {
+ // See discussion: http://autopackage.org/forums/viewtopic.php?t=22
+ static void** libc_stack_end;
+
+ if( libc_stack_end == libc_stack_end.init )
+ {
+ void* handle = dlopen( null, RTLD_NOW );
+ libc_stack_end = cast(void**) dlsym( handle, "__libc_stack_end" );
+ dlclose( handle );
+ }
+ return *libc_stack_end;
+ }
+ }
+ else version( freebsd )
+ {
+ version( SimpleLibcStackEnd )
+ {
+ return __libc_stack_end;
+ }
+ else
+ {
+ // See discussion: http://autopackage.org/forums/viewtopic.php?t=22
+ static void** libc_stack_end;
+
+ if( libc_stack_end == libc_stack_end.init )
+ {
+ void* handle = dlopen( null, RTLD_NOW );
+ libc_stack_end = cast(void**) dlsym( handle, "__libc_stack_end" );
+ dlclose( handle );
+ }
+ return *libc_stack_end;
+ }
+ }
+ else version( darwin )
+ {
+ // darwin has a fixed stack bottom
+ version( D_LP64 )
+ return cast(void*) 0x7fff5fc00000;
+ else
+ return cast(void*) 0xc0000000;
+ }
+ else version( solaris )
+ {
+ version(X86_64) {
+ return _userlimit;
+ }
+ else {
+ //
+ return cast(void*) 0x8048000;
+ }
+ }
+ else
+ {
+ static assert( false, "Operating system not supported." );
+ }
+}
+
+
+/**
+ *
+ */
+extern (C) void* rt_stackTop()
+{
+ version( D_InlineAsm_X86 )
+ {
+ asm
+ {
+ naked;
+ mov EAX, ESP;
+ ret;
+ }
+ }
+ else
+ {
+ return llvm_frameaddress();
+ }
+}
+
+
+private
+{
+ version( Win32 )
+ {
+ extern (C)
+ {
+ extern __gshared int _data_start__;
+ extern __gshared int _bss_end__;
+ }
+
+ alias _data_start__ Data_Start;
+ alias _bss_end__ Data_End;
+ }
+ else version( linux )
+ {
+ extern (C)
+ {
+ extern __gshared int _data;
+ extern __gshared int __data_start;
+ extern __gshared int _end;
+ extern __gshared int _data_start__;
+ extern __gshared int _data_end__;
+ extern __gshared int _bss_start__;
+ extern __gshared int _bss_end__;
+ extern __gshared int __fini_array_end;
+ }
+
+ alias __data_start Data_Start;
+ alias _end Data_End;
+ }
+ else version( freebsd )
+ {
+ extern (C)
+ {
+ extern __gshared char etext;
+ extern __gshared int _end;
+ }
+
+ alias etext Data_Start;
+ alias _end Data_End;
+ }
+ else version( solaris )
+ {
+ extern(C)
+ {
+ extern __gshared int _environ;
+ extern __gshared int _end;
+ }
+
+ alias _environ Data_Start;
+ alias _end Data_End;
+ }
+
+ version( GC_Use_Dynamic_Ranges )
+ {
+ private import core.stdc.stdlib;
+ }
+
+ void* dataStart, dataEnd;
+}
+
+
+void initStaticDataGC()
+{
+
+ static const int S = (void*).sizeof;
+
+ // Can't assume the input addresses are word-aligned
+ static void* adjust_up( void* p )
+ {
+ return p + ((S - (cast(size_t)p & (S-1))) & (S-1)); // cast ok even if 64-bit
+ }
+
+ static void * adjust_down( void* p )
+ {
+ return p - (cast(size_t) p & (S-1));
+ }
+
+ version( Win32 )
+ {
+ dataStart = adjust_up( &Data_Start );
+ dataEnd = adjust_down( &Data_End );
+ }
+ else version(linux)
+ {
+ dataStart = adjust_up( &Data_Start );
+ dataEnd = adjust_down( &Data_End );
+ }
+ else version( freebsd )
+ {
+ dataStart = adjust_up( &Data_Start );
+ dataEnd = adjust_down( &Data_End );
+ }
+ else version(solaris)
+ {
+ dataStart = adjust_up( &Data_Start );
+ dataEnd = adjust_down( &Data_End );
+ }
+ else version(GC_Use_Data_Dyld)
+ {
+ _d_dyld_start();
+ }
+ else
+ {
+ static assert( false, "Operating system not supported." );
+ }
+
+ version( GC_Use_Data_Proc_Maps )
+ {
+ parseDataProcMaps();
+ }
+ gc_addRange(dataStart, dataEnd - dataStart);
+}
+
+version( GC_Use_Data_Proc_Maps )
+{
+version(solaris)
+{
+ typedef long offset_t;
+ enum : uint { PRMAPSZ = 64, MA_WRITE = 0x02 }
+ extern(C)
+ {
+ struct prmap {
+ uintptr_t pr_vaddr; /* virtual address of mapping */
+ size_t pr_size; /* size of mapping in bytes */
+ char[PRMAPSZ] pr_mapname; /* name in /proc//object */
+ private offset_t pr_offset; /* offset into mapped object, if any */
+ int pr_mflags; /* protection and attribute flags (see below) */
+ int pr_pagesize; /* pagesize (bytes) for this mapping */
+ int pr_shmid; /* SysV shmid, -1 if not SysV shared memory */
+
+ private int[1] pr_filler;
+ }
+ }
+
+ debug (ProcMaps) extern (C) int printf(char*, ...);
+
+ void parseDataProcMaps()
+ {
+ debug (ProcMaps) printf("initStaticDataPtrs()\n");
+ // http://docs.sun.com/app/docs/doc/816-5174/proc-4
+ prmap pr;
+
+ int fd = open("/proc/self/map", O_RDONLY);
+ scope (exit) close(fd);
+
+ while (prmap.sizeof == read(fd, &pr, prmap.sizeof))
+ if (pr.pr_mflags & MA_WRITE)
+ {
+ void* start = cast(void*) pr.pr_vaddr;
+ void* end = cast(void*)(pr.pr_vaddr + pr.pr_size);
+ debug (ProcMaps) printf(" vmem at %p - %p with size %d bytes\n", start, end, pr.pr_size);
+
+ // Exclude stack and dataStart..dataEnd
+ if ( ( !dataEnd ||
+ !( dataStart >= start && dataEnd <= end ) ) &&
+ !( &pr >= start && &pr < end ) )
+ {
+ // we already have static data from this region. anything else
+ // is heap (%% check)
+ debug (ProcMaps) printf(" Adding map range %p - %p\n", start, end);
+ gc_addRange(start, end - start);
+ }
+ }
+ }
+}
+else
+{
+ const int S = (void*).sizeof;
+
+ // TODO: This could use cleanup!
+ void parseDataProcMaps()
+ {
+ // TODO: Exclude zero-mapped regions
+
+ int fd = open("/proc/self/maps", O_RDONLY);
+ ptrdiff_t count; // %% need to configure ret for read..
+ char buf[2024];
+ char* p;
+ char* e;
+ char* s;
+ void* start;
+ void* end;
+
+ p = buf.ptr;
+ if (fd != -1)
+ {
+ while ( (count = read(fd, p, buf.sizeof - (p - buf.ptr))) > 0 )
+ {
+ e = p + count;
+ p = buf.ptr;
+ while (true)
+ {
+ s = p;
+ while (p < e && *p != '\n')
+ p++;
+ if (p < e)
+ {
+ // parse the entry in [s, p)
+ static if( S == 4 )
+ {
+ enum Ofs
+ {
+ Write_Prot = 19,
+ Start_Addr = 0,
+ End_Addr = 9,
+ Addr_Len = 8,
+ }
+ }
+ else static if( S == 8 )
+ {
+ //X86-64 only has 12 bytes address space(in PAE mode) - not 16
+ //We also need the 32 bit offsets for 32 bit apps
+ version(X86_64) {
+ enum Ofs
+ {
+ Write_Prot = 27,
+ Start_Addr = 0,
+ End_Addr = 13,
+ Addr_Len = 12,
+ Write_Prot_32 = 19,
+ Start_Addr_32 = 0,
+ End_Addr_32 = 9,
+ Addr_Len_32 = 8,
+ }
+ }
+ else
+ {
+ enum Ofs
+ {
+ Write_Prot = 35,
+ Start_Addr = 0,
+ End_Addr = 9,
+ Addr_Len = 17,
+ }
+ }
+ }
+ else
+ {
+ static assert( false );
+ }
+
+ // %% this is wrong for 64-bit:
+ // long strtoul(const char*,char**,int);
+ // but seems to work on x86-64:
+ // probably because C's long is 64 bit there
+
+ if( s[Ofs.Write_Prot] == 'w' )
+ {
+ s[Ofs.Start_Addr + Ofs.Addr_Len] = '\0';
+ s[Ofs.End_Addr + Ofs.Addr_Len] = '\0';
+ start = cast(void*) strtoul(s + Ofs.Start_Addr, null, 16);
+ end = cast(void*) strtoul(s + Ofs.End_Addr, null, 16);
+
+ // 1. Exclude anything overlapping [dataStart, dataEnd)
+ // 2. Exclude stack
+ if ( ( !dataEnd ||
+ !( dataStart >= start && dataEnd <= end ) ) &&
+ !( &buf[0] >= start && &buf[0] < end ) )
+ {
+ // we already have static data from this region. anything else
+ // is heap (%% check)
+ debug (ProcMaps) printf("Adding map range %p 0%p\n", start, end);
+ gc_addRange(start, end - start);
+ }
+ }
+ version(X86_64)
+ {
+ //We need to check here for 32 bit apps like ldc produces
+ //and add them to the gc scan range
+ if( s[Ofs.Write_Prot_32] == 'w' )
+ {
+ s[Ofs.Start_Addr_32 + Ofs.Addr_Len_32] = '\0';
+ s[Ofs.End_Addr_32 + Ofs.Addr_Len_32] = '\0';
+ start = cast(void*) strtoul(s + Ofs.Start_Addr_32, null, 16);
+ end = cast(void*) strtoul(s + Ofs.End_Addr_32, null, 16);
+ if ( ( !dataEnd ||
+ !( dataStart >= start && dataEnd <= end ) ) &&
+ !( &buf[0] >= start && &buf[0] < end ) )
+ {
+ gc_addRange(start, end - start);
+ }
+ }
+ }
+
+ p++;
+ }
+ else
+ {
+ count = p - s;
+ memmove(buf.ptr, s, cast(size_t)count);
+ p = buf.ptr + count;
+ break;
+ }
+ }
+ }
+ close(fd);
+ }
+ }
+}
+}
+
+/*
+ * GDC dyld memory module:
+ * http://www.dsource.org/projects/tango/browser/trunk/lib/compiler/gdc/memory_dyld.c
+ * Port to the D programming language: Jacob Carlborg
+ */
+version (GC_Use_Data_Dyld)
+{
+ private
+ {
+ const char* SEG_DATA = "__DATA".ptr;
+ const char* SECT_DATA = "__data".ptr;
+ const char* SECT_BSS = "__bss".ptr;
+ const char* SECT_COMMON = "__common".ptr;
+
+ struct SegmentSection
+ {
+ const char* segment;
+ const char* section;
+ }
+
+ struct mach_header
+ {
+ uint magic;
+ int cputype;
+ int cpusubtype;
+ uint filetype;
+ uint ncmds;
+ uint sizeofcmds;
+ uint flags;
+ version (D_LP64)
+ uint reserved;
+ }
+
+ struct section
+ {
+ char[16] sectname;
+ char[16] segname;
+ c_ulong addr;
+ c_ulong size;
+ uint offset;
+ uint align_;
+ uint reloff;
+ uint nreloc;
+ uint flags;
+ uint reserved1;
+ uint reserved2;
+ version (D_LP64)
+ uint reserved3;
+ }
+
+ alias extern (C) void function (mach_header* mh, ptrdiff_t vmaddr_slide) DyldFuncPointer;
+
+ version (D_LP64)
+ extern (C) /*const*/ section* getsectbynamefromheader_64(/*const*/ mach_header* mhp, /*const*/ char* segname, /*const*/ char* sectname);
+ else
+ extern (C) /*const*/ section* getsectbynamefromheader(/*const*/ mach_header* mhp, /*const*/ char* segname, /*const*/ char* sectname);
+ extern (C) void _dyld_register_func_for_add_image(DyldFuncPointer func);
+ extern (C) void _dyld_register_func_for_remove_image(DyldFuncPointer func);
+
+ const SegmentSection[3] GC_dyld_sections = [SegmentSection(SEG_DATA, SECT_DATA), SegmentSection(SEG_DATA, SECT_BSS), SegmentSection(SEG_DATA, SECT_COMMON)];
+
+ extern (C) void on_dyld_add_image (/*const*/ mach_header* hdr, ptrdiff_t slide)
+ {
+ void* start;
+ void* end;
+ /*const*/ section* sec;
+
+ foreach (s ; GC_dyld_sections)
+ {
+ version (D_LP64)
+ sec = getsectbynamefromheader_64(hdr, s.segment, s.section);
+ else
+ sec = getsectbynamefromheader(hdr, s.segment, s.section);
+
+ if (sec == null || sec.size == 0)
+ continue;
+
+ start = cast(void*) (sec.addr + slide);
+ end = cast(void*) (start + sec.size);
+
+ gc_addRange(start, end - start);
+ }
+ }
+
+ extern (C) void on_dyld_remove_image (/*const*/ mach_header* hdr, ptrdiff_t slide)
+ {
+ void* start;
+ void* end;
+ /*const*/ section* sec;
+
+ foreach (s ; GC_dyld_sections)
+ {
+ version (D_LP64)
+ sec = getsectbynamefromheader_64(hdr, s.segment, s.section);
+ else
+ sec = getsectbynamefromheader(hdr, s.segment, s.section);
+
+ if (sec == null || sec.size == 0)
+ continue;
+
+ start = cast(void*) (sec.addr + slide);
+ end = cast(void*) (start + sec.size);
+
+ gc_removeRange(start);
+ }
+ }
+
+ void _d_dyld_start ()
+ {
+ static bool started;
+
+ if (!started)
+ {
+ started = true;
+
+ _dyld_register_func_for_add_image(&on_dyld_add_image);
+ _dyld_register_func_for_remove_image(&on_dyld_remove_image);
+ }
+ }
+ }
+}
+
+}
+else
+{
+ static assert( false, "Compiler not supported." );
+}
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/rt/qsort.d druntime/src/rt/qsort.d
--- druntime-orig/src/rt/qsort.d 2010-12-15 10:30:48.000000000 +0300
+++ druntime/src/rt/qsort.d 2011-01-05 14:40:22.000000000 +0300
@@ -44,7 +44,7 @@
structures. The default value is optimized for a high cost for compares. */
-extern (C) long _adSort(Array a, TypeInfo ti)
+extern (C) void[] _adSort(void[] a, TypeInfo ti)
{
byte*[40] stack; // stack
byte* i, j; // scan and limit pointers
@@ -121,7 +121,7 @@
limit = sp[1];
}
else // else stack empty, all done
- return *cast(long*)(&a);
+ return a;
}
assert(0);
}
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/rt/qsort2.d druntime/src/rt/qsort2.d
--- druntime-orig/src/rt/qsort2.d 2010-12-15 10:30:48.000000000 +0300
+++ druntime/src/rt/qsort2.d 2011-01-05 14:40:22.000000000 +0300
@@ -32,14 +32,14 @@
return tiglobal.compare(p1, p2);
}
-extern (C) long _adSort(Array a, TypeInfo ti)
+extern (C) void[] _adSort(void[] a, TypeInfo ti)
{
synchronized
{
tiglobal = ti;
qsort(a.ptr, a.length, cast(size_t)ti.tsize(), &cmp);
}
- return *cast(long*)(&a);
+ return a;
}
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/rt/trace.d druntime/src/rt/trace.d
--- druntime-orig/src/rt/trace.d 2010-12-15 10:30:48.000000000 +0300
+++ druntime/src/rt/trace.d 2011-01-05 14:40:22.000000000 +0300
@@ -829,7 +829,7 @@
version (OSX)
{ // 16 byte align stack
asm
- { naked ;
+ {
pushad ;
sub ESP,12 ;
}
@@ -844,7 +844,7 @@
else
{
asm
- { naked ;
+ {
pushad ;
}
trace_epi();
diff -U 3 -H -d -r -N -x '*.mak' -x tk -x backend -x debug -x release -x '*_pch.h' -x Makefile -x '*.rej' -x '*~' -x '*.log' -x .svn -x '*pro.user' -x .directory -x cmake_install -x CMakeFiles -x .preprocessed.tmp -x 'Makefile.*' -x '*.orig' -- druntime-orig/src/std/intrinsic.d druntime/src/std/intrinsic.d
--- druntime-orig/src/std/intrinsic.d 1970-01-01 03:00:00.000000000 +0300
+++ druntime/src/std/intrinsic.d 2011-01-05 18:02:19.255062853 +0300
@@ -0,0 +1,215 @@
+/*
+ * D phobos intrinsics for LDC
+ *
+ * From GDC ... public domain!
+ */
+module std.intrinsic;
+
+// Check for the right compiler
+version(LDC)
+{
+ // OK
+}
+else
+{
+ static assert(false, "This module is only valid for LDC");
+}
+
+nothrow:
+
+/**
+ * Scans the bits in v starting with bit 0, looking
+ * for the first set bit.
+ * Returns:
+ * The bit number of the first bit set.
+ * The return value is undefined if v is zero.
+ */
+pure int bsf(size_t v)
+{
+ uint m = 1;
+ uint i;
+ for (i = 0; i < 32; i++,m<<=1) {
+ if (v&m)
+ return i;
+ }
+ return i; // supposed to be undefined
+}
+
+/**
+ * Scans the bits in v from the most significant bit
+ * to the least significant bit, looking
+ * for the first set bit.
+ * Returns:
+ * The bit number of the first bit set.
+ * The return value is undefined if v is zero.
+ * Example:
+ * ---
+ * import std.intrinsic;
+ *
+ * int main()
+ * {
+ * uint v;
+ * int x;
+ *
+ * v = 0x21;
+ * x = bsf(v);
+ * printf("bsf(x%x) = %d\n", v, x);
+ * x = bsr(v);
+ * printf("bsr(x%x) = %d\n", v, x);
+ * return 0;
+ * }
+ * ---
+ * Output:
+ * bsf(x21) = 0
+ * bsr(x21) = 5
+ */
+pure int bsr(size_t v)
+{
+ uint m = 0x80000000;
+ uint i;
+ for (i = 32; i ; i--,m>>>=1) {
+ if (v&m)
+ return i-1;
+ }
+ return i; // supposed to be undefined
+}
+
+
+/**
+ * Tests the bit.
+ */
+pure int bt(in size_t* p, size_t bitnum)
+{
+ return (p[bitnum / (uint.sizeof*8)] & (1<<(bitnum & ((uint.sizeof*8)-1)))) ? -1 : 0 ;
+}
+
+
+/**
+ * Tests and complements the bit.
+ */
+int btc(size_t* p, size_t bitnum)
+{
+ uint * q = p + (bitnum / (uint.sizeof*8));
+ uint mask = 1 << (bitnum & ((uint.sizeof*8) - 1));
+ int result = *q & mask;
+ *q ^= mask;
+ return result ? -1 : 0;
+}
+
+
+/**
+ * Tests and resets (sets to 0) the bit.
+ */
+int btr(size_t* p, size_t bitnum)
+{
+ uint * q = p + (bitnum / (uint.sizeof*8));
+ uint mask = 1 << (bitnum & ((uint.sizeof*8) - 1));
+ int result = *q & mask;
+ *q &= ~mask;
+ return result ? -1 : 0;
+}
+
+
+/**
+ * Tests and sets the bit.
+ * Params:
+ * p = a non-NULL pointer to an array of uints.
+ * index = a bit number, starting with bit 0 of p[0],
+ * and progressing. It addresses bits like the expression:
+---
+p[index / (uint.sizeof*8)] & (1 << (index & ((uint.sizeof*8) - 1)))
+---
+ * Returns:
+ * A non-zero value if the bit was set, and a zero
+ * if it was clear.
+ *
+ * Example:
+ * ---
+import std.intrinsic;
+
+int main()
+{
+ uint array[2];
+
+ array[0] = 2;
+ array[1] = 0x100;
+
+ printf("btc(array, 35) = %d\n", btc(array, 35));
+ printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
+
+ printf("btc(array, 35) = %d\n", btc(array, 35));
+ printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
+
+ printf("bts(array, 35) = %d\n", bts(array, 35));
+ printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
+
+ printf("btr(array, 35) = %d\n", btr(array, 35));
+ printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
+
+ printf("bt(array, 1) = %d\n", bt(array, 1));
+ printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
+
+ return 0;
+}
+ * ---
+ * Output:
+
+btc(array, 35) = 0
+array = [0]:x2, [1]:x108
+btc(array, 35) = -1
+array = [0]:x2, [1]:x100
+bts(array, 35) = 0
+array = [0]:x2, [1]:x108
+btr(array, 35) = -1
+array = [0]:x2, [1]:x100
+bt(array, 1) = -1
+array = [0]:x2, [1]:x100
+
+ */
+int bts(size_t* p, size_t bitnum)
+{
+ uint * q = p + (bitnum / (uint.sizeof*8));
+ uint mask = 1 << (bitnum & ((uint.sizeof*8) - 1));
+ int result = *q & mask;
+ *q |= mask;
+ return result ? -1 : 0;
+}
+
+/**
+ * Swaps bytes in a 4 byte uint end-to-end, i.e. byte 0 becomes
+ * byte 3, byte 1 becomes byte 2, byte 2 becomes byte 1, byte 3
+ * becomes byte 0.
+ */
+pure pragma(intrinsic, "llvm.bswap.i32")
+ uint bswap(uint val);
+
+/**
+ * Reads I/O port at port_address.
+ */
+ubyte inp(uint port_address) { assert(false && "inp intrinsic not yet implemented"); };
+
+/**
+ * ditto
+ */
+ushort inpw(uint port_address) { assert(false && "inpw intrinsic not yet implemented"); };
+
+/**
+ * ditto
+ */
+uint inpl(uint port_address) { assert(false && "inpl intrinsic not yet implemented"); };
+
+
+/**
+ * Writes and returns value to I/O port at port_address.
+ */
+ubyte outp(uint port_address, ubyte value) { assert(false && "outp intrinsic not yet implemented"); };
+
+/**
+ * ditto
+ */
+ushort outpw(uint port_address, ushort value) { assert(false && "outpw intrinsic not yet implemented"); };
+
+/**
+ * ditto
+ */
+uint outpl(uint port_address, uint value) { assert(false && "outpl intrinsic not yet implemented"); };