libphobos: Merge upstream druntime 109f0f2e

Backports more extern(C) bindings and platform ports.

Reviewed-on: https://github.com/dlang/druntime/pull/2569

From-SVN: r270490

12 files changed, 277 insertions, 143 deletions

diff --git a/libphobos/libdruntime/MERGE b/libphobos/libdruntime/MERGE
index 405be92..8a37901 100644
--- a/libphobos/libdruntime/MERGE
+++ b/libphobos/libdruntime/MERGE
@@ -1,4 +1,4 @@
-4b2674b36b1f6aac75db2a5aa38d67d4be55a987
+109f0f2e11aaaddd2b158117928e10c3c4688870
 
 The first line of this file holds the git revision number of the last
 merge done from the dlang/druntime repository.
diff --git a/libphobos/libdruntime/core/runtime.d b/libphobos/libdruntime/core/runtime.d
index 1fd5440..848b607 100644
--- a/libphobos/libdruntime/core/runtime.d
+++ b/libphobos/libdruntime/core/runtime.d
@@ -464,10 +464,14 @@ extern (C) bool runModuleUnitTests()
         import core.sys.freebsd.execinfo;
     else version (NetBSD)
         import core.sys.netbsd.execinfo;
+    else version (DragonFlyBSD)
+        import core.sys.dragonflybsd.execinfo;
     else version (Windows)
         import core.sys.windows.stacktrace;
     else version (Solaris)
         import core.sys.solaris.execinfo;
+    else version (CRuntime_UClibc)
+        import core.sys.linux.execinfo;
 
     static if ( __traits( compiles, new LibBacktrace(0) ) )
     {
@@ -591,10 +595,14 @@ Throwable.TraceInfo defaultTraceHandler( void* ptr = null )
         import core.sys.freebsd.execinfo;
     else version (NetBSD)
         import core.sys.netbsd.execinfo;
+    else version (DragonFlyBSD)
+        import core.sys.dragonflybsd.execinfo;
     else version (Windows)
         import core.sys.windows.stacktrace;
     else version (Solaris)
         import core.sys.solaris.execinfo;
+    else version (CRuntime_UClibc)
+        import core.sys.linux.execinfo;
 
     // avoid recursive GC calls in finalizer, trace handlers should be made @nogc instead
     import core.memory : gc_inFinalizer;
@@ -709,6 +717,8 @@ Throwable.TraceInfo defaultTraceHandler( void* ptr = null )
 
                 version (linux) enum enableDwarf = true;
                 else version (FreeBSD) enum enableDwarf = true;
+                else version (DragonFlyBSD) enum enableDwarf = true;
+                else version (Darwin) enum enableDwarf = true;
                 else enum enableDwarf = false;
 
                 static if (enableDwarf)
@@ -832,6 +842,18 @@ Throwable.TraceInfo defaultTraceHandler( void* ptr = null )
                         symEnd = eptr - buf.ptr;
                     }
                 }
+                else version (DragonFlyBSD)
+                {
+                    // format is: 0x00000000 <_D6module4funcAFZv+0x78> at module
+                    auto bptr = cast(char*) memchr( buf.ptr, '<', buf.length );
+                    auto eptr = cast(char*) memchr( buf.ptr, '+', buf.length );
+
+                    if ( bptr++ && eptr )
+                    {
+                        symBeg = bptr - buf.ptr;
+                        symEnd = eptr - buf.ptr;
+                    }
+                }
                 else version (Solaris)
                 {
                     // format is object'symbol+offset [pc]
@@ -896,7 +918,7 @@ Throwable.TraceInfo defaultTraceHandler( void* ptr = null )
         {
             static enum FIRSTFRAME = 0;
         }
-        import core.sys.windows.windows : CONTEXT;
+        import core.sys.windows.winnt : CONTEXT;
         auto s = new StackTrace(FIRSTFRAME, cast(CONTEXT*)ptr);
         return s;
     }
diff --git a/libphobos/libdruntime/core/stdc/math.d b/libphobos/libdruntime/core/stdc/math.d
index e93f853..9b19004 100644
--- a/libphobos/libdruntime/core/stdc/math.d
+++ b/libphobos/libdruntime/core/stdc/math.d
@@ -2041,46 +2041,49 @@ else version (FreeBSD)
 {
   version (none) // < 8-CURRENT
   {
-    real    acosl(real x) { return acos(x); }
-    real    asinl(real x) { return asin(x); }
-    pure real    atanl(real x) { return atan(x); }
-    real    atan2l(real y, real x) { return atan2(y, x); }
-    pure real    cosl(real x) { return cos(x); }
-    pure real    sinl(real x) { return sin(x); }
-    pure real    tanl(real x) { return tan(x); }
-    real    exp2l(real x) { return exp2(x); }
-    pure 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    modfl(real value, real *iptr); // nontrivial conversion
-    real    scalbnl(real x, int n) { return scalbn(x, n); }
-    real    scalblnl(real x, c_long n) { return scalbln(x, n); }
-    pure real    fabsl(real x) { return fabs(x); }
-    real    hypotl(real x, real y) { return hypot(x, y); }
-    real    sqrtl(real x) { return sqrt(x); }
-    pure real    ceill(real x) { return ceil(x); }
-    pure real    floorl(real x) { return floor(x); }
-    pure real    nearbyintl(real x) { return nearbyint(x); }
-    pure real    rintl(real x) { return rint(x); }
-    c_long  lrintl(real x) { return lrint(x); }
-    pure real    roundl(real x) { return round(x); }
-    c_long  lroundl(real x) { return lround(x); }
-    long    llroundl(real x) { return llround(x); }
-    pure 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); }
-    pure real    copysignl(real x, real y) { return copysign(x, y); }
-//  pure double  nan(char* tagp);
-//  pure float   nanf(char* tagp);
-//  pure real    nanl(char* tagp);
-    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); }
-    pure real    fmaxl(real x, real y) { return fmax(x, y); }
-    pure real    fminl(real x, real y) { return fmin(x, y); }
-    pure real    fmal(real x, real y, real z) { return fma(x, y, z); }
+    extern (D)
+    {
+        real    acosl(real x) { return acos(x); }
+        real    asinl(real x) { return asin(x); }
+        pure real    atanl(real x) { return atan(x); }
+        real    atan2l(real y, real x) { return atan2(y, x); }
+        pure real    cosl(real x) { return cos(x); }
+        pure real    sinl(real x) { return sin(x); }
+        pure real    tanl(real x) { return tan(x); }
+        real    exp2l(real x) { return exp2(x); }
+        pure 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    modfl(real value, real *iptr); // nontrivial conversion
+        real    scalbnl(real x, int n) { return scalbn(x, n); }
+        real    scalblnl(real x, c_long n) { return scalbln(x, n); }
+        pure real    fabsl(real x) { return fabs(x); }
+        real    hypotl(real x, real y) { return hypot(x, y); }
+        real    sqrtl(real x) { return sqrt(x); }
+        pure real    ceill(real x) { return ceil(x); }
+        pure real    floorl(real x) { return floor(x); }
+        pure real    nearbyintl(real x) { return nearbyint(x); }
+        pure real    rintl(real x) { return rint(x); }
+        c_long  lrintl(real x) { return lrint(x); }
+        pure real    roundl(real x) { return round(x); }
+        c_long  lroundl(real x) { return lround(x); }
+        long    llroundl(real x) { return llround(x); }
+        pure 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); }
+        pure real    copysignl(real x, real y) { return copysign(x, y); }
+        //pure double  nan(char* tagp);
+        //pure float   nanf(char* tagp);
+        //pure real    nanl(char* tagp);
+        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); }
+        pure real    fmaxl(real x, real y) { return fmax(x, y); }
+        pure real    fminl(real x, real y) { return fmin(x, y); }
+        pure real    fmal(real x, real y, real z) { return fma(x, y, z); }
+    }
   }
   else
   {
@@ -2205,49 +2208,49 @@ else version (FreeBSD)
     ///
     float   acoshf(float x);
     ///
-    real    acoshl(real x) { return acosh(x); }
+    extern(D) real acoshl(real x) { return acosh(x); }
 
     ///
     pure double  asinh(double x);
     ///
     pure float   asinhf(float x);
     ///
-    pure real    asinhl(real x) { return asinh(x); }
+    extern(D) pure real asinhl(real x) { return asinh(x); }
 
     ///
     double  atanh(double x);
     ///
     float   atanhf(float x);
     ///
-    real    atanhl(real x) { return atanh(x); }
+    extern(D) real atanhl(real x) { return atanh(x); }
 
     ///
     double  cosh(double x);
     ///
     float   coshf(float x);
     ///
-    real    coshl(real x) { return cosh(x); }
+    extern(D) real coshl(real x) { return cosh(x); }
 
     ///
     double  sinh(double x);
     ///
     float   sinhf(float x);
     ///
-    real    sinhl(real x) { return sinh(x); }
+    extern(D) real sinhl(real x) { return sinh(x); }
 
     ///
     pure double  tanh(double x);
     ///
     pure float   tanhf(float x);
     ///
-    pure real    tanhl(real x) { return tanh(x); }
+    extern(D) pure real tanhl(real x) { return tanh(x); }
 
     ///
     double  exp(double x);
     ///
     float   expf(float x);
     ///
-    real    expl(real x) { return exp(x); }
+    extern(D) real expl(real x) { return exp(x); }
 
     ///
     double  exp2(double x);
@@ -2259,7 +2262,7 @@ else version (FreeBSD)
     ///
     float   expm1f(float x);
     ///
-    real    expm1l(real x) { return expm1(x); }
+    extern(D) real expm1l(real x) { return expm1(x); }
 
     ///
     pure double  frexp(double value, int* exp);
@@ -2281,29 +2284,29 @@ else version (FreeBSD)
     ///
     float   logf(float x);
     ///
-    real    logl(real x) { return log(x); }
+    extern(D) real logl(real x) { return log(x); }
 
     ///
     double  log10(double x);
     ///
     float   log10f(float x);
     ///
-    real    log10l(real x) { return log10(x); }
+    extern(D) real log10l(real x) { return log10(x); }
 
     ///
     double  log1p(double x);
     ///
     float   log1pf(float x);
     ///
-    real    log1pl(real x) { return log1p(x); }
+    extern(D) 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; }
+    extern(D) double log2(double x) { return log(x) * ONE_LN2; }
     ///
-    float   log2f(float x) { return logf(x) * ONE_LN2; }
+    extern(D) float  log2f(float x) { return logf(x) * ONE_LN2; }
     ///
-    real    log2l(real x)  { return logl(x) * ONE_LN2; }
+    extern(D) real   log2l(real x)  { return logl(x) * ONE_LN2; }
 
     ///
     double  logb(double x);
@@ -2330,7 +2333,7 @@ else version (FreeBSD)
     ///
     pure float   cbrtf(float x);
     ///
-    pure real    cbrtl(real x) { return cbrt(x); }
+    extern(D) pure real cbrtl(real x) { return cbrt(x); }
 
     ///
     pure double  fabs(double x);
@@ -2347,7 +2350,7 @@ else version (FreeBSD)
     ///
     float   powf(float x, float y);
     ///
-    real    powl(real x, real y) { return pow(x, y); }
+    extern(D) real powl(real x, real y) { return pow(x, y); }
 
     ///
     double  sqrt(double x);
@@ -2359,28 +2362,28 @@ else version (FreeBSD)
     ///
     pure float   erff(float x);
     ///
-    pure real    erfl(real x) { return erf(x); }
+    extern(D) pure real erfl(real x) { return erf(x); }
 
     ///
     double  erfc(double x);
     ///
     float   erfcf(float x);
     ///
-    real    erfcl(real x) { return erfc(x); }
+    extern(D) real erfcl(real x) { return erfc(x); }
 
     ///
     double  lgamma(double x);
     ///
     float   lgammaf(float x);
     ///
-    real    lgammal(real x) { return lgamma(x); }
+    extern(D) real lgammal(real x) { return lgamma(x); }
 
     ///
     double  tgamma(double x);
     ///
     float   tgammaf(float x);
     ///
-    real    tgammal(real x) { return tgamma(x); }
+    extern(D) real tgammal(real x) { return tgamma(x); }
 
     ///
     pure double  ceil(double x);
@@ -2412,7 +2415,7 @@ else version (FreeBSD)
     ///
     long    llrintf(float x);
     ///
-    long    llrintl(real x) { return llrint(x); }
+    extern(D) long llrintl(real x) { return llrint(x); }
 
     ///
     pure double  round(double x);
@@ -2532,13 +2535,13 @@ else version (NetBSD)
     ///
     pure real    rintl(real x);
     ///
-    c_long  lrintl(real x) { return cast(c_long)rintl(x); }
+    extern(D) c_long lrintl(real x) { return cast(c_long)rintl(x); }
     ///
     pure real    roundl(real x);
     ///
-    c_long  lroundl(real x) { return cast(c_long)roundl(x);}
+    extern(D) c_long lroundl(real x) { return cast(c_long)roundl(x);}
     ///
-    long    llroundl(real x) { return cast(long)roundl(x);}
+    extern(D) long llroundl(real x) { return cast(long)roundl(x);}
     ///
     pure real    truncl(real x);
     ///
@@ -2558,7 +2561,7 @@ else version (NetBSD)
     ///
     real    nextafterl(real x, real y);
     ///
-    real    nexttowardl(real x, real y) { return nexttoward(cast(double) x, cast(double) y); }
+    extern(D) real nexttowardl(real x, real y) { return nexttoward(cast(double) x, cast(double) y); }
     ///
     real    fdiml(real x, real y);
     ///
@@ -2740,13 +2743,13 @@ else version (NetBSD)
     ///
     float   log1pf(float x);
     ///
-    real    log1pl(real x) { return log1p(cast(double) x); }
+    extern(D) real log1pl(real x) { return log1p(cast(double) x); }
 
     private enum real ONE_LN2 = 1 / 0x1.62e42fefa39ef358p-1L;
     ///
-    double  log2(double x) { return log(x) * ONE_LN2; }
+    extern(D) double log2(double x) { return log(x) * ONE_LN2; }
     ///
-    float   log2f(float x) { return logf(x) * ONE_LN2; }
+    extern(D) float log2f(float x) { return logf(x) * ONE_LN2; }
     ///
     real    log2l(real x)  { return logl(x) * ONE_LN2; }
 
@@ -2804,7 +2807,7 @@ else version (NetBSD)
     ///
     pure float   erff(float x);
     ///
-    pure real    erfl(real x) { return erf(cast(double) x); }
+    extern(D) pure real erfl(real x) { return erf(cast(double) x); }
 
     ///
     double  erfc(double x);
@@ -2857,7 +2860,7 @@ else version (NetBSD)
     ///
     long    llrintf(float x);
     ///
-    long    llrintl(real x) { return cast(long)rintl(x); }
+    extern(D) long llrintl(real x) { return cast(long)rintl(x); }
 
     ///
     pure double  round(double x);
@@ -3988,399 +3991,399 @@ else version (CRuntime_UClibc)
     ///
     float   acosf(float x);
     ///
-    real    acosl(real x) { return acos(cast(double) x); }
+    extern(D) real acosl(real x) { return acos(cast(double) x); }
 
     ///
     double  asin(double x);
     ///
     float   asinf(float x);
     ///
-    real    asinl(real x) { return asin(cast(double) x); }
+    extern(D) real asinl(real x) { return asin(cast(double) x); }
 
     ///
     pure double  atan(double x);
     ///
     pure float   atanf(float x);
     ///
-    pure real    atanl(real x) { return atan(cast(double) x); }
+    extern(D) pure real atanl(real x) { return atan(cast(double) x); }
 
     ///
     double  atan2(double y, double x);
     ///
     float   atan2f(float y, float x);
     ///
-    real    atan2l(real y, real x) { return atan2(cast(double) x, cast(double) y); }
+    extern(D) real atan2l(real y, real x) { return atan2(cast(double) x, cast(double) y); }
 
     ///
     pure double  cos(double x);
     ///
     pure float   cosf(float x);
     ///
-    pure real    cosl(real x) { return cos(cast(double) x); }
+    extern(D) pure real cosl(real x) { return cos(cast(double) x); }
 
     ///
     pure double  sin(double x);
     ///
     pure float   sinf(float x);
     ///
-    pure real    sinl(real x) { return sin(cast(double) x); }
+    extern(D) pure real sinl(real x) { return sin(cast(double) x); }
 
     ///
     pure double  tan(double x);
     ///
     pure float   tanf(float x);
     ///
-    pure real    tanl(real x) { return tan(cast(double) x); }
+    extern(D) pure real tanl(real x) { return tan(cast(double) x); }
 
     ///
     double  acosh(double x);
     ///
     float   acoshf(float x);
     ///
-    real    acoshl(real x) { return acosh(cast(double) x); }
+    extern(D) real acoshl(real x) { return acosh(cast(double) x); }
 
     ///
     pure double  asinh(double x);
     ///
     pure float   asinhf(float x);
     ///
-    pure real    asinhl(real x) { return asinh(cast(double) x); }
+    extern(D) pure real asinhl(real x) { return asinh(cast(double) x); }
 
     ///
     double  atanh(double x);
     ///
     float   atanhf(float x);
     ///
-    real    atanhl(real x) { return atanh(cast(double) x); }
+    extern(D) real atanhl(real x) { return atanh(cast(double) x); }
 
     ///
     double  cosh(double x);
     ///
     float   coshf(float x);
     ///
-    real    coshl(real x) { return cosh(cast(double) x); }
+    extern(D) real coshl(real x) { return cosh(cast(double) x); }
 
     ///
     double  sinh(double x);
     ///
     float   sinhf(float x);
     ///
-    real    sinhl(real x) { return sinh(cast(double) x); }
+    extern(D) real sinhl(real x) { return sinh(cast(double) x); }
 
     ///
     double  tanh(double x);
     ///
     float   tanhf(float x);
     ///
-    real    tanhl(real x) { return tanh(cast(double) x); }
+    extern(D) real tanhl(real x) { return tanh(cast(double) x); }
 
     ///
     double  exp(double x);
     ///
     float   expf(float x);
     ///
-    real    expl(real x) { return exp(cast(double) x); }
+    extern(D) real expl(real x) { return exp(cast(double) x); }
 
     ///
     double  exp2(double x);
     ///
     float   exp2f(float x);
     ///
-    real    exp2l(real x) { return exp2(cast(double) x); }
+    extern(D) real exp2l(real x) { return exp2(cast(double) x); }
 
     ///
     double  expm1(double x);
     ///
     float   expm1f(float x);
     ///
-    real    expm1l(real x) { return expm1(cast(double) x); }
+    extern(D) real expm1l(real x) { return expm1(cast(double) x); }
 
     ///
     pure double  frexp(double value, int* exp);
     ///
     pure float   frexpf(float value, int* exp);
     ///
-    pure real    frexpl(real value, int* exp) { return frexp(cast(double) value, exp); }
+    extern(D) pure real frexpl(real value, int* exp) { return frexp(cast(double) value, exp); }
 
     ///
     int     ilogb(double x);
     ///
     int     ilogbf(float x);
     ///
-    int     ilogbl(real x) { return ilogb(cast(double) x); }
+    extern(D) int ilogbl(real x) { return ilogb(cast(double) x); }
 
     ///
     double  ldexp(double x, int exp);
     ///
     float   ldexpf(float x, int exp);
     ///
-    real    ldexpl(real x, int exp) { return ldexp(cast(double) x, exp); }
+    extern(D) real ldexpl(real x, int exp) { return ldexp(cast(double) x, exp); }
 
     ///
     double  log(double x);
     ///
     float   logf(float x);
     ///
-    real    logl(real x) { return log(cast(double) x); }
+    extern(D) real logl(real x) { return log(cast(double) x); }
 
     ///
     double  log10(double x);
     ///
     float   log10f(float x);
     ///
-    real    log10l(real x) { return log10(cast(double) x); }
+    extern(D) real log10l(real x) { return log10(cast(double) x); }
 
     ///
     double  log1p(double x);
     ///
     float   log1pf(float x);
     ///
-    real    log1pl(real x) { return log1p(cast(double) x); }
+    extern(D) real log1pl(real x) { return log1p(cast(double) x); }
 
     ///
     double  log2(double x);
     ///
     float   log2f(float x);
     ///
-    real    log2l(real x) { return log2(cast(double) x); }
+    extern(D) real log2l(real x) { return log2(cast(double) x); }
 
     ///
     double  logb(double x);
     ///
     float   logbf(float x);
     ///
-    real    logbl(real x) { return logb(cast(double) x); }
+    extern(D) real logbl(real x) { return logb(cast(double) x); }
 
     ///
     pure double  modf(double value, double* iptr);
     ///
     pure float   modff(float value, float* iptr);
     ///
-    pure real    modfl(real value, real *iptr) { return modf(cast(double) value, cast(double*) iptr); }
+    extern(D) pure real modfl(real value, real *iptr) { return modf(cast(double) value, cast(double*) iptr); }
 
     ///
     double  scalbn(double x, int n);
     ///
     float   scalbnf(float x, int n);
     ///
-    real    scalbnl(real x, int n) { return scalbln(cast(double) x, n); }
+    extern(D) real scalbnl(real x, int n) { return scalbln(cast(double) x, n); }
 
     ///
     double  scalbln(double x, c_long n);
     ///
     float   scalblnf(float x, c_long n);
     ///
-    real    scalblnl(real x, c_long n) { return scalbln(cast(double) x, n); }
+    extern(D) real scalblnl(real x, c_long n) { return scalbln(cast(double) x, n); }
 
     ///
     pure double  cbrt(double x);
     ///
     pure float   cbrtf(float x);
     ///
-    pure real    cbrtl(real x) { return cbrt(cast(double) x); }
+    extern(D) pure real cbrtl(real x) { return cbrt(cast(double) x); }
 
     ///
     pure double  fabs(double x);
     ///
     pure float   fabsf(float x);
     ///
-    pure real    fabsl(real x) { return fabs(cast(double) x); }
+    extern(D) pure real fabsl(real x) { return fabs(cast(double) x); }
 
     ///
     double  hypot(double x, double y);
     ///
     float   hypotf(float x, float y);
     ///
-    real    hypotl(real x, real y) { return hypot(cast(double) x, cast(double) y); }
+    extern(D) real hypotl(real x, real y) { return hypot(cast(double) x, cast(double) y); }
 
     ///
     double  pow(double x, double y);
     ///
     float   powf(float x, float y);
     ///
-    real    powl(real x, real y) { return pow(cast(double) x, cast(double) y); }
+    extern(D) real powl(real x, real y) { return pow(cast(double) x, cast(double) y); }
 
     ///
     double  sqrt(double x);
     ///
     float   sqrtf(float x);
     ///
-    real    sqrtl(real x) { return sqrt(cast(double) x); }
+    extern(D) real sqrtl(real x) { return sqrt(cast(double) x); }
 
     ///
     pure double  erf(double x);
     ///
     pure float   erff(float x);
     ///
-    pure real    erfl(real x) { return erf(cast(double) x); }
+    extern(D) pure real erfl(real x) { return erf(cast(double) x); }
 
     ///
     double  erfc(double x);
     ///
     float   erfcf(float x);
     ///
-    real    erfcl(real x) { return erfc(cast(double) x); }
+    extern(D) real erfcl(real x) { return erfc(cast(double) x); }
 
     ///
     double  lgamma(double x);
     ///
     float   lgammaf(float x);
     ///
-    real    lgammal(real x) { return lgamma(cast(double) x); }
+    extern(D) real lgammal(real x) { return lgamma(cast(double) x); }
 
     ///
     double  tgamma(double x);
     ///
     float   tgammaf(float x);
     ///
-    real    tgammal(real x) { return tgamma(cast(double) x); }
+    extern(D) real tgammal(real x) { return tgamma(cast(double) x); }
 
     ///
     pure double  ceil(double x);
     ///
     pure float   ceilf(float x);
     ///
-    pure real    ceill(real x) { return ceil(cast(double) x); }
+    extern(D) pure real ceill(real x) { return ceil(cast(double) x); }
 
     ///
     pure double  floor(double x);
     ///
     pure float   floorf(float x);
     ///
-    pure real    floorl(real x) { return floor(cast(double) x); }
+    extern(D) pure real floorl(real x) { return floor(cast(double) x); }
 
     ///
     pure double  nearbyint(double x);
     ///
     pure float   nearbyintf(float x);
     ///
-    pure real    nearbyintl(real x) { return nearbyint(cast(double) x); }
+    extern(D) pure real nearbyintl(real x) { return nearbyint(cast(double) x); }
 
     ///
     pure double  rint(double x);
     ///
     pure float   rintf(float x);
     ///
-    pure real    rintl(real x) { return rint(cast(double) x); }
+    extern(D) pure real rintl(real x) { return rint(cast(double) x); }
 
     ///
     c_long  lrint(double x);
     ///
     c_long  lrintf(float x);
     ///
-    c_long  lrintl(real x) { return lrint(cast(double) x); }
+    extern(D) c_long lrintl(real x) { return lrint(cast(double) x); }
 
     ///
     long    llrint(double x);
     ///
     long    llrintf(float x);
     ///
-    long    llrintl(real x) { return llrint(cast(double) x); }
+    extern(D) long llrintl(real x) { return llrint(cast(double) x); }
 
     ///
     pure double  round(double x);
     ///
     pure float   roundf(float x);
     ///
-    pure real    roundl(real x) { return round(cast(double) x); }
+    extern(D) pure real roundl(real x) { return round(cast(double) x); }
 
     ///
     c_long  lround(double x);
     ///
     c_long  lroundf(float x);
     ///
-    c_long  lroundl(real x) { return lround(cast(double) x); }
+    extern(D) c_long lroundl(real x) { return lround(cast(double) x); }
 
     ///
     long    llround(double x);
     ///
     long    llroundf(float x);
     ///
-    long    llroundl(real x) { return llround(cast(double) x); }
+    extern(D) long llroundl(real x) { return llround(cast(double) x); }
 
     ///
     pure double  trunc(double x);
     ///
     pure float   truncf(float x);
     ///
-    pure real    truncl(real x) { return trunc(cast(double) x); }
+    extern(D) pure real truncl(real x) { return trunc(cast(double) x); }
 
     ///
     double  fmod(double x, double y);
     ///
     float   fmodf(float x, float y);
     ///
-    real    fmodl(real x, real y) { return fmod(cast(double) x, cast(double) y); }
+    extern(D) real fmodl(real x, real y) { return fmod(cast(double) x, cast(double) y); }
 
     ///
     double  remainder(double x, double y);
     ///
     float   remainderf(float x, float y);
     ///
-    real    remainderl(real x, real y) { return remainder(cast(double) x, cast(double) y); }
+    extern(D) real remainderl(real x, real y) { return remainder(cast(double) x, cast(double) 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) { return remquo(cast(double) x, cast(double) y, quo); }
+    extern(D) real remquol(real x, real y, int* quo) { return remquo(cast(double) x, cast(double) y, quo); }
 
     ///
     pure double  copysign(double x, double y);
     ///
     pure float   copysignf(float x, float y);
     ///
-    pure real    copysignl(real x, real y) { return copysign(cast(double) x, cast(double) y); }
+    extern(D) pure real copysignl(real x, real y) { return copysign(cast(double) x, cast(double) y); }
 
     ///
     pure double  nan(char* tagp);
     ///
     pure float   nanf(char* tagp);
     ///
-    pure real    nanl(char* tagp) { return nan(tagp); }
+    extern(D) pure real nanl(char* tagp) { return nan(tagp); }
 
     ///
     double  nextafter(double x, double y);
     ///
     float   nextafterf(float x, float y);
     ///
-    real    nextafterl(real x, real y) { return nextafter(cast(double) x, cast(double) y); }
+    extern(D) real nextafterl(real x, real y) { return nextafter(cast(double) x, cast(double) y); }
 
     ///
     double  nexttoward(double x, real y);
     ///
     float   nexttowardf(float x, real y);
     ///
-    real    nexttowardl(real x, real y) { return nexttoward(cast(double) x, cast(double) y); }
+    extern(D) real nexttowardl(real x, real y) { return nexttoward(cast(double) x, cast(double) y); }
 
     ///
     double  fdim(double x, double y);
     ///
     float   fdimf(float x, float y);
     ///
-    real    fdiml(real x, real y) { return fdim(cast(double) x, cast(double) y); }
+    extern(D) real fdiml(real x, real y) { return fdim(cast(double) x, cast(double) y); }
 
     ///
     pure double  fmax(double x, double y);
     ///
     pure float   fmaxf(float x, float y);
     ///
-    pure real    fmaxl(real x, real y) { return fmax(cast(double) x, cast(double) y); }
+    extern(D) pure real fmaxl(real x, real y) { return fmax(cast(double) x, cast(double) y); }
 
     ///
     pure double  fmin(double x, double y);
     ///
     pure float   fminf(float x, float y);
     ///
-    pure real    fminl(real x, real y) { return fmin(cast(double) x, cast(double) y); }
+    extern(D) pure real fminl(real x, real y) { return fmin(cast(double) x, cast(double) y); }
 
     ///
     pure double  fma(double x, double y, double z);
     ///
     pure float   fmaf(float x, float y, float z);
     ///
-    pure real    fmal(real x, real y, real z) { return fma(cast(double) x, cast(double) y, cast(double) z); }
+    extern(D) pure real fmal(real x, real y, real z) { return fma(cast(double) x, cast(double) y, cast(double) z); }
 }
 else
 {
diff --git a/libphobos/libdruntime/core/sys/posix/fcntl.d b/libphobos/libdruntime/core/sys/posix/fcntl.d
index 2f1daf6..867356c 100644
--- a/libphobos/libdruntime/core/sys/posix/fcntl.d
+++ b/libphobos/libdruntime/core/sys/posix/fcntl.d
@@ -120,6 +120,13 @@ version (CRuntime_Glibc)
     enum F_SETLK        = 6;
     enum F_SETLKW       = 7;
   }
+  else version (SystemZ)
+  {
+    static assert(off_t.sizeof == 8);
+    enum F_GETLK        = 5;
+    enum F_SETLK        = 6;
+    enum F_SETLKW       = 7;
+  }
   else
   static if ( __USE_FILE_OFFSET64 )
   {
diff --git a/libphobos/libdruntime/core/sys/posix/spawn.d b/libphobos/libdruntime/core/sys/posix/spawn.d
index f5e6c6d..aa59c2f 100644
--- a/libphobos/libdruntime/core/sys/posix/spawn.d
+++ b/libphobos/libdruntime/core/sys/posix/spawn.d
@@ -239,7 +239,8 @@ else version (Darwin)
         // POSIX_SPAWN_SETSCHEDPARAM = 0x10,  // not supported
         // POSIX_SPAWN_SETSCHEDULER = 0x20,   // ditto
         POSIX_SPAWN_SETEXEC = 0x40,
-        POSIX_SPAWN_START_SUSPENDED = 0x80
+        POSIX_SPAWN_START_SUSPENDED = 0x80,
+        POSIX_SPAWN_CLOEXEC_DEFAULT = 0x4000
     }
     alias posix_spawnattr_t = void*;
     alias posix_spawn_file_actions_t = void*;
@@ -288,6 +289,8 @@ else version (NetBSD)
         uint len;
         posix_spawn_file_actions_entry_t* fae;
     }
+    alias posix_spawnattr_t = posix_spawnattr;
+    alias posix_spawn_file_actions_t = posix_spawn_file_actions;
 }
 else version (OpenBSD)
 {
diff --git a/libphobos/libdruntime/core/sys/posix/sys/stat.d b/libphobos/libdruntime/core/sys/posix/sys/stat.d
index 53858e7..ab1fcd7 100644
--- a/libphobos/libdruntime/core/sys/posix/sys/stat.d
+++ b/libphobos/libdruntime/core/sys/posix/sys/stat.d
@@ -799,12 +799,12 @@ version (CRuntime_Glibc)
             alias __ino_t = c_ulong;
             alias __ino64_t = ulong;
             alias __mode_t = uint;
-            alias __nlink_t = uint;
+            alias __nlink_t = ulong;
             alias __uid_t = uint;
             alias __gid_t = uint;
             alias __off_t = c_long;
             alias __off64_t = long;
-            alias __blksize_t = int;
+            alias __blksize_t = c_long;
             alias __blkcnt_t = c_long;
             alias __blkcnt64_t = long;
             alias __timespec = timespec;
diff --git a/libphobos/libdruntime/core/thread.d b/libphobos/libdruntime/core/thread.d
index 0466e7a..3d2cd28 100644
--- a/libphobos/libdruntime/core/thread.d
+++ b/libphobos/libdruntime/core/thread.d
@@ -1187,7 +1187,7 @@ class Thread
             }
             else
             {
-                // NOTE: pthread_setschedprio is not implemented on Darwin or FreeBSD, so use
+                // NOTE: pthread_setschedprio is not implemented on Darwin, FreeBSD or DragonFlyBSD, so use
                 //       the more complicated get/set sequence below.
                 int         policy;
                 sched_param param;
@@ -3202,8 +3202,11 @@ extern (C) @nogc nothrow
     version (CRuntime_Glibc) int pthread_getattr_np(pthread_t thread, pthread_attr_t* attr);
     version (FreeBSD) int pthread_attr_get_np(pthread_t thread, pthread_attr_t* attr);
     version (NetBSD) int pthread_attr_get_np(pthread_t thread, pthread_attr_t* attr);
+    version (DragonFlyBSD) int pthread_attr_get_np(pthread_t thread, pthread_attr_t* attr);
     version (Solaris) int thr_stksegment(stack_t* stk);
     version (CRuntime_Bionic) int pthread_getattr_np(pthread_t thid, pthread_attr_t* attr);
+    version (CRuntime_Musl) int pthread_getattr_np(pthread_t, pthread_attr_t*);
+    version (CRuntime_UClibc) int pthread_getattr_np(pthread_t thread, pthread_attr_t* attr);
 }
 
 
@@ -3292,6 +3295,19 @@ private void* getStackBottom() nothrow @nogc
             addr += size;
         return addr;
     }
+    else version (DragonFlyBSD)
+    {
+        pthread_attr_t attr;
+        void* addr; size_t size;
+
+        pthread_attr_init(&attr);
+        pthread_attr_get_np(pthread_self(), &attr);
+        pthread_attr_getstack(&attr, &addr, &size);
+        pthread_attr_destroy(&attr);
+        version (StackGrowsDown)
+            addr += size;
+        return addr;
+    }
     else version (Solaris)
     {
         stack_t stk;
@@ -3311,6 +3327,30 @@ private void* getStackBottom() nothrow @nogc
             addr += size;
         return addr;
     }
+    else version (CRuntime_Musl)
+    {
+        pthread_attr_t attr;
+        void* addr; size_t size;
+
+        pthread_getattr_np(pthread_self(), &attr);
+        pthread_attr_getstack(&attr, &addr, &size);
+        pthread_attr_destroy(&attr);
+        version (StackGrowsDown)
+            addr += size;
+        return addr;
+    }
+    else version (CRuntime_UClibc)
+    {
+        pthread_attr_t attr;
+        void* addr; size_t size;
+
+        pthread_getattr_np(pthread_self(), &attr);
+        pthread_attr_getstack(&attr, &addr, &size);
+        pthread_attr_destroy(&attr);
+        version (StackGrowsDown)
+            addr += size;
+        return addr;
+    }
     else
         static assert(false, "Platform not supported.");
 }
@@ -4569,8 +4609,10 @@ private:
             version (Posix) import core.sys.posix.sys.mman; // mmap
             version (FreeBSD) import core.sys.freebsd.sys.mman : MAP_ANON;
             version (NetBSD) import core.sys.netbsd.sys.mman : MAP_ANON;
+            version (DragonFlyBSD) import core.sys.dragonflybsd.sys.mman : MAP_ANON;
             version (CRuntime_Glibc) import core.sys.linux.sys.mman : MAP_ANON;
             version (Darwin) import core.sys.darwin.sys.mman : MAP_ANON;
+            version (CRuntime_UClibc) import core.sys.linux.sys.mman : MAP_ANON;
 
             static if ( __traits( compiles, mmap ) )
             {
@@ -5612,6 +5654,27 @@ version (FreeBSD) unittest
     thr.join();
 }
 
+version (DragonFlyBSD) unittest
+{
+    static void loop()
+    {
+        pthread_attr_t attr;
+        pthread_attr_init(&attr);
+        auto thr = pthread_self();
+        foreach (i; 0 .. 50)
+            pthread_attr_get_np(thr, &attr);
+        pthread_attr_destroy(&attr);
+    }
+
+    auto thr = new Thread(&loop).start();
+    foreach (i; 0 .. 50)
+    {
+        thread_suspendAll();
+        thread_resumeAll();
+    }
+    thr.join();
+}
+
 unittest
 {
     // use >PAGESIZE to avoid stack overflow (e.g. in an syscall)
diff --git a/libphobos/libdruntime/rt/aApplyR.d b/libphobos/libdruntime/rt/aApplyR.d
index 4b39f70..b29d370 100644
--- a/libphobos/libdruntime/rt/aApplyR.d
+++ b/libphobos/libdruntime/rt/aApplyR.d
@@ -272,7 +272,7 @@ extern (C) int _aApplyRwc1(in wchar[] aa, dg_t dg)
 
         if (d & ~0x7F)
         {
-            char[4] buf;
+            char[4] buf = void;
 
             auto b = toUTF8(buf, d);
             foreach (char c2; b)
@@ -348,7 +348,7 @@ extern (C) int _aApplyRdc1(in dchar[] aa, dg_t dg)
 
         if (d & ~0x7F)
         {
-            char[4] buf;
+            char[4] buf = void;
 
             auto b = toUTF8(buf, d);
             foreach (char c2; b)
@@ -741,7 +741,7 @@ extern (C) int _aApplyRwc2(in wchar[] aa, dg2_t dg)
 
         if (d & ~0x7F)
         {
-            char[4] buf;
+            char[4] buf = void;
 
             auto b = toUTF8(buf, d);
             foreach (char c2; b)
@@ -819,7 +819,7 @@ extern (C) int _aApplyRdc2(in dchar[] aa, dg2_t dg)
 
         if (d & ~0x7F)
         {
-            char[4] buf;
+            char[4] buf = void;
 
             auto b = toUTF8(buf, d);
             foreach (char c2; b)
diff --git a/libphobos/libdruntime/rt/config.d b/libphobos/libdruntime/rt/config.d
index fb791ea..904f721 100644
--- a/libphobos/libdruntime/rt/config.d
+++ b/libphobos/libdruntime/rt/config.d
@@ -115,7 +115,7 @@ string rt_envvarsOption(string opt, scope rt_configCallBack dg) @nogc nothrow
         if (opt.length >= 32)
             assert(0);
 
-        char[40] var;
+        char[40] var = void;
         var[0 .. 4] = "DRT_";
         foreach (i, c; opt)
             var[4 + i] = cast(char) toupper(c);
diff --git a/libphobos/libdruntime/rt/dmain2.d b/libphobos/libdruntime/rt/dmain2.d
index d937689..f45565c 100644
--- a/libphobos/libdruntime/rt/dmain2.d
+++ b/libphobos/libdruntime/rt/dmain2.d
@@ -42,6 +42,10 @@ version (NetBSD)
 {
     import core.stdc.fenv;
 }
+version (DragonFlyBSD)
+{
+    import core.stdc.fenv;
+}
 
 extern (C) void _d_monitor_staticctor();
 extern (C) void _d_monitor_staticdtor();
diff --git a/libphobos/libdruntime/rt/monitor_.d b/libphobos/libdruntime/rt/monitor_.d
index 8d301ad..e38b015 100644
--- a/libphobos/libdruntime/rt/monitor_.d
+++ b/libphobos/libdruntime/rt/monitor_.d
@@ -193,7 +193,8 @@ else version (Windows)
     {
         pragma(lib, "snn.lib");
     }
-    import core.sys.windows.windows;
+    import core.sys.windows.winbase /+: CRITICAL_SECTION, DeleteCriticalSection,
+        EnterCriticalSection, InitializeCriticalSection, LeaveCriticalSection+/;
 
     alias Mutex = CRITICAL_SECTION;
 
@@ -206,6 +207,7 @@ else version (Posix)
 {
     import core.sys.posix.pthread;
 
+@nogc:
     alias Mutex = pthread_mutex_t;
     __gshared pthread_mutexattr_t gattr;
 
@@ -244,17 +246,17 @@ struct Monitor
 
 private:
 
-@property ref shared(Monitor*) monitor(Object h) pure nothrow
+@property ref shared(Monitor*) monitor(Object h) pure nothrow @nogc
 {
     return *cast(shared Monitor**)&h.__monitor;
 }
 
-private shared(Monitor)* getMonitor(Object h) pure
+private shared(Monitor)* getMonitor(Object h) pure @nogc
 {
     return atomicLoad!(MemoryOrder.acq)(h.monitor);
 }
 
-void setMonitor(Object h, shared(Monitor)* m) pure
+void setMonitor(Object h, shared(Monitor)* m) pure @nogc
 {
     atomicStore!(MemoryOrder.rel)(h.monitor, m);
 }
@@ -296,7 +298,7 @@ shared(Monitor)* ensureMonitor(Object h)
     }
 }
 
-void deleteMonitor(Monitor* m)
+void deleteMonitor(Monitor* m) @nogc
 {
     destroyMutex(&m.mtx);
     free(m);
diff --git a/libphobos/libdruntime/rt/qsort.d b/libphobos/libdruntime/rt/qsort.d
index af0c1eb..079a0f5 100644
--- a/libphobos/libdruntime/rt/qsort.d
+++ b/libphobos/libdruntime/rt/qsort.d
@@ -75,6 +75,21 @@ else version (FreeBSD)
         return a;
     }
 }
+else version (DragonFlyBSD)
+{
+    alias extern (C) int function(scope void *, scope const void *, scope const void *) Cmp;
+    extern (C) void qsort_r(scope void *base, size_t nmemb, size_t size, scope void *thunk, Cmp cmp);
+
+    extern (C) void[] _adSort(return scope void[] a, TypeInfo ti)
+    {
+        extern (C) int cmp(scope void* ti, scope const void* p1, scope const void* p2)
+        {
+            return (cast(TypeInfo)ti).compare(p1, p2);
+        }
+        qsort_r(a.ptr, a.length, ti.tsize, cast(void*)ti, &cmp);
+        return a;
+    }
+}
 else version (Darwin)
 {
     alias extern (C) int function(scope void *, scope const void *, scope const void *) Cmp;
@@ -90,6 +105,21 @@ else version (Darwin)
         return a;
     }
 }
+else version (CRuntime_UClibc)
+{
+    alias extern (C) int function(scope const void *, scope const void *, scope void *) __compar_d_fn_t;
+    extern (C) void qsort_r(scope void *base, size_t nmemb, size_t size, __compar_d_fn_t cmp, scope void *arg);
+
+    extern (C) void[] _adSort(return scope void[] a, TypeInfo ti)
+    {
+        extern (C) int cmp(scope const void* p1, scope const void* p2, scope void* ti)
+        {
+            return (cast(TypeInfo)ti).compare(p1, p2);
+        }
+        qsort_r(a.ptr, a.length, ti.tsize, &cmp, cast(void*)ti);
+        return a;
+    }
+}
 else
 {
     private TypeInfo tiglobal;