druntime: redirect dual-ABI functions on glibc to IEEE128 version ...

... if IEEE long double ABI is selected

Author: liushuyu

druntime/src/core/stdc/math.d

@@ -4285,195 +4285,223 @@ else
     ///
     float   acosf(float x);
     ///
+    pragma(mangle, __acosl_mangle)
     real    acosl(real x);
 
     ///
     double  asin(double x);
     ///
     float   asinf(float x);
     ///
+    pragma(mangle, __asinl_mangle)
     real    asinl(real x);
 
     ///
     pure double  atan(double x);
     ///
     pure float   atanf(float x);
     ///
+    pragma(mangle, __atanl_mangle)
     pure real    atanl(real x);
 
     ///
     double  atan2(double y, double x);
     ///
     float   atan2f(float y, float x);
     ///
+    pragma(mangle, __atan2l_mangle)
     real    atan2l(real y, real x);
 
     ///
     pure double  cos(double x);
     ///
     pure float   cosf(float x);
     ///
+    pragma(mangle, __cosl_mangle)
     pure real    cosl(real x);
 
     ///
     pure double  sin(double x);
     ///
     pure float   sinf(float x);
     ///
+    pragma(mangle, __sinl_mangle)
     pure real    sinl(real x);
 
     ///
     pure double  tan(double x);
     ///
     pure float   tanf(float x);
     ///
+    pragma(mangle, __tanl_mangle)
     pure real    tanl(real x);
 
     ///
     double  acosh(double x);
     ///
     float   acoshf(float x);
     ///
+    pragma(mangle, __acoshl_mangle)
     real    acoshl(real x);
 
     ///
     pure double  asinh(double x);
     ///
     pure float   asinhf(float x);
     ///
+    pragma(mangle, __asinhl_mangle)
     pure real    asinhl(real x);
 
     ///
     double  atanh(double x);
     ///
     float   atanhf(float x);
     ///
+    pragma(mangle, __atanhl_mangle)
     real    atanhl(real x);
 
     ///
     double  cosh(double x);
     ///
     float   coshf(float x);
     ///
+    pragma(mangle, __coshl_mangle)
     real    coshl(real x);
 
     ///
     double  sinh(double x);
     ///
     float   sinhf(float x);
     ///
+    pragma(mangle, __sinhl_mangle)
     real    sinhl(real x);
 
     ///
     pure double  tanh(double x);
     ///
     pure float   tanhf(float x);
     ///
+    pragma(mangle, __tanhl_mangle)
     pure real    tanhl(real x);
 
     ///
     double  exp(double x);
     ///
     float   expf(float x);
     ///
+    pragma(mangle, __expl_mangle)
     real    expl(real x);
 
     ///
     double  exp2(double x);
     ///
     float   exp2f(float x);
     ///
+    pragma(mangle, __exp2l_mangle)
     real    exp2l(real x);
 
     ///
     double  expm1(double x);
     ///
     float   expm1f(float x);
     ///
+    pragma(mangle, __expm1l_mangle)
     real    expm1l(real x);
 
     ///
     pure double  frexp(double value, int* exp);
     ///
     pure float   frexpf(float value, int* exp);
     ///
+    pragma(mangle, __frexpl_mangle)
     pure real    frexpl(real value, int* exp);
 
     ///
     int     ilogb(double x);
     ///
     int     ilogbf(float x);
     ///
+    pragma(mangle, __ilogbl_mangle)
     int     ilogbl(real x);
 
     ///
     double  ldexp(double x, int exp);
     ///
     float   ldexpf(float x, int exp);
     ///
+    pragma(mangle, __ldexpl_mangle)
     real    ldexpl(real x, int exp);
 
     ///
     double  log(double x);
     ///
     float   logf(float x);
     ///
+    pragma(mangle, __logl_mangle)
     real    logl(real x);
 
     ///
     double  log10(double x);
     ///
     float   log10f(float x);
     ///
+    pragma(mangle, __log10l_mangle)
     real    log10l(real x);
 
     ///
     double  log1p(double x);
     ///
     float   log1pf(float x);
     ///
+    pragma(mangle, __log1pl_mangle)
     real    log1pl(real x);
 
     ///
     double  log2(double x);
     ///
     float   log2f(float x);
     ///
+    pragma(mangle, __log2l_mangle)
     real    log2l(real x);
 
     ///
     double  logb(double x);
     ///
     float   logbf(float x);
     ///
+    pragma(mangle, __logbl_mangle)
     real    logbl(real x);
 
     ///
     pure double  modf(double value, double* iptr);
     ///
     pure float   modff(float value, float* iptr);
     ///
+    pragma(mangle, __modfl_mangle)
     pure real    modfl(real value, real *iptr);
 
     ///
     double  scalbn(double x, int n);
     ///
     float   scalbnf(float x, int n);
     ///
+    pragma(mangle, __scalbnl_mangle)
     real    scalbnl(real x, int n);
 
     ///
     double  scalbln(double x, c_long n);
     ///
     float   scalblnf(float x, c_long n);
     ///
+    pragma(mangle, __scalblnl_mangle)
     real    scalblnl(real x, c_long n);
 
     ///
     pure double  cbrt(double x);
     ///
     pure float   cbrtf(float x);
     ///
+    pragma(mangle, __cbrtl_mangle)
     pure real    cbrtl(real x);
 
     ///
@@ -4486,6 +4514,7 @@ else
         ///
         pure float   fabsf(float x);
         ///
+    pragma(mangle, __fabsl_mangle)
         pure real    fabsl(real x);
     }
 
@@ -4494,194 +4523,349 @@ else
     ///
     float   hypotf(float x, float y);
     ///
+    pragma(mangle, __hypotl_mangle)
     real    hypotl(real x, real y);
 
     ///
     double  pow(double x, double y);
     ///
     float   powf(float x, float y);
     ///
+    pragma(mangle, __powl_mangle)
     real    powl(real x, real y);
 
     ///
     double  sqrt(double x);
     ///
     float   sqrtf(float x);
     ///
+    pragma(mangle, __sqrtl_mangle)
     real    sqrtl(real x);
 
     ///
     pure double  erf(double x);
     ///
     pure float   erff(float x);
     ///
+    pragma(mangle, __erfl_mangle)
     pure real    erfl(real x);
 
     ///
     double  erfc(double x);
     ///
     float   erfcf(float x);
     ///
+    pragma(mangle, __erfcl_mangle)
     real    erfcl(real x);
 
     ///
     double  lgamma(double x);
     ///
     float   lgammaf(float x);
     ///
+    pragma(mangle, __lgammal_mangle)
     real    lgammal(real x);
 
     ///
     double  tgamma(double x);
     ///
     float   tgammaf(float x);
     ///
+    pragma(mangle, __tgammal_mangle)
     real    tgammal(real x);
 
     ///
     pure double  ceil(double x);
     ///
     pure float   ceilf(float x);
     ///
+    pragma(mangle, __ceill_mangle)
     pure real    ceill(real x);
 
     ///
     pure double  floor(double x);
     ///
     pure float   floorf(float x);
     ///
+    pragma(mangle, __floorl_mangle)
     pure real    floorl(real x);
 
     ///
     pure double  nearbyint(double x);
     ///
     pure float   nearbyintf(float x);
     ///
+    pragma(mangle, __nearbyintl_mangle)
     pure real    nearbyintl(real x);
 
     ///
     pure double  rint(double x);
     ///
     pure float   rintf(float x);
     ///
+    pragma(mangle, __rintl_mangle)
     pure real    rintl(real x);
 
     ///
     c_long  lrint(double x);
     ///
     c_long  lrintf(float x);
     ///
+    pragma(mangle, __lrintl_mangle)
     c_long  lrintl(real x);
 
     ///
     long    llrint(double x);
     ///
     long    llrintf(float x);
     ///
+    pragma(mangle, __llrintl_mangle)
     long    llrintl(real x);
 
     ///
     pure double  round(double x);
     ///
     pure float   roundf(float x);
     ///
+    pragma(mangle, __roundl_mangle)
     pure real    roundl(real x);
 
     ///
     c_long  lround(double x);
     ///
     c_long  lroundf(float x);
     ///
+    pragma(mangle, __lroundl_mangle)
     c_long  lroundl(real x);
 
     ///
     long    llround(double x);
     ///
     long    llroundf(float x);
     ///
+    pragma(mangle, __llroundl_mangle)
     long    llroundl(real x);
 
     ///
     pure double  trunc(double x);
     ///
     pure float   truncf(float x);
     ///
+    pragma(mangle, __truncl_mangle)
     pure real    truncl(real x);
 
     ///
     double  fmod(double x, double y);
     ///
     float   fmodf(float x, float y);
     ///
+    pragma(mangle, __fmodl_mangle)
     real    fmodl(real x, real y);
 
     ///
     double  remainder(double x, double y);
     ///
     float   remainderf(float x, float y);
     ///
+    pragma(mangle, __remainderl_mangle)
     real    remainderl(real x, real y);
 
     ///
     double  remquo(double x, double y, int* quo);
     ///
     float   remquof(float x, float y, int* quo);
     ///
+    pragma(mangle, __remquol_mangle)
     real    remquol(real x, real y, int* quo);
 
     ///
     pure double  copysign(double x, double y);
     ///
     pure float   copysignf(float x, float y);
     ///
+    pragma(mangle, __copysignl_mangle)
     pure real    copysignl(real x, real y);
 
     ///
     pure double  nan(char* tagp);
     ///
     pure float   nanf(char* tagp);
     ///
+    pragma(mangle, __nanl_mangle)
     pure real    nanl(char* tagp);
 
     ///
     double  nextafter(double x, double y);
     ///
     float   nextafterf(float x, float y);
     ///
+    pragma(mangle, __nextafterl_mangle)
     real    nextafterl(real x, real y);
 
     ///
+    pragma(mangle, __nexttoward_mangle)
     double  nexttoward(double x, real y);
     ///
+    pragma(mangle, __nexttowardf_mangle)
     float   nexttowardf(float x, real y);
     ///
+    pragma(mangle, __nexttowardl_mangle)
     real    nexttowardl(real x, real y);
 
     ///
     double  fdim(double x, double y);
     ///
     float   fdimf(float x, float y);
     ///
+    pragma(mangle, __fdiml_mangle)
     real    fdiml(real x, real y);
 
     ///
     pure double  fmax(double x, double y);
     ///
     pure float   fmaxf(float x, float y);
     ///
+    pragma(mangle, __fmaxl_mangle)
     pure real    fmaxl(real x, real y);
 
     ///
     pure double  fmin(double x, double y);
     ///
     pure float   fminf(float x, float y);
     ///
+    pragma(mangle, __fminl_mangle)
     pure real    fminl(real x, real y);
 
     ///
     pure double  fma(double x, double y, double z);
     ///
     pure float   fmaf(float x, float y, float z);
     ///
+    pragma(mangle, __fmal_mangle)
     pure real    fmal(real x, real y, real z);
+
+    version (D_PPCUseIEEE128)
+    {
+        enum __acoshl_mangle = "__acoshieee128";
+        enum __acosl_mangle = "__acosieee128";
+        enum __asinhl_mangle = "__asinhieee128";
+        enum __asinl_mangle = "__asinieee128";
+        enum __atan2l_mangle = "__atan2ieee128";
+        enum __atanhl_mangle = "__atanhieee128";
+        enum __atanl_mangle = "__atanieee128";
+        enum __cbrtl_mangle = "__cbrtieee128";
+        enum __ceill_mangle = "__ceilieee128";
+        enum __copysignl_mangle = "__copysignieee128";
+        enum __coshl_mangle = "__coshieee128";
+        enum __cosl_mangle = "__cosieee128";
+        enum __erfcl_mangle = "__erfcieee128";
+        enum __erfl_mangle = "__erfieee128";
+        enum __exp2l_mangle = "__exp2ieee128";
+        enum __expl_mangle = "__expieee128";
+        enum __expm1l_mangle = "__expm1ieee128";
+        enum __fabsl_mangle = "__fabsieee128";
+        enum __fdiml_mangle = "__fdimieee128";
+        enum __floorl_mangle = "__floorieee128";
+        enum __fmal_mangle = "__fmaieee128";
+        enum __fmaxl_mangle = "__fmaxieee128";
+        enum __fminl_mangle = "__fminieee128";
+        enum __fmodl_mangle = "__fmodieee128";
+        enum __frexpl_mangle = "__frexpieee128";
+        enum __hypotl_mangle = "__hypotieee128";
+        enum __ilogbl_mangle = "__ilogbieee128";
+        enum __ldexpl_mangle = "__ldexpieee128";
+        enum __lgammal_mangle = "__lgammaieee128";
+        enum __llrintl_mangle = "__llrintieee128";
+        enum __llroundl_mangle = "__llroundieee128";
+        enum __log10l_mangle = "__log10ieee128";
+        enum __log1pl_mangle = "__log1pieee128";
+        enum __log2l_mangle = "__log2ieee128";
+        enum __logbl_mangle = "__logbieee128";
+        enum __logl_mangle = "__logieee128";
+        enum __lrintl_mangle = "__lrintieee128";
+        enum __lroundl_mangle = "__lroundieee128";
+        enum __modfl_mangle = "__modfieee128";
+        enum __nanl_mangle = "__nanieee128";
+        enum __nearbyintl_mangle = "__nearbyintieee128";
+        enum __nextafterl_mangle = "__nextafterieee128";
+        enum __nexttoward_mangle = "__nexttoward_to_ieee128";
+        enum __nexttowardf_mangle = "__nexttowardf_to_ieee128";
+        enum __nexttowardl_mangle = "__nexttowardieee128";
+        enum __powl_mangle = "__powieee128";
+        enum __remainderl_mangle = "__remainderieee128";
+        enum __remquol_mangle = "__remquoieee128";
+        enum __rintl_mangle = "__rintieee128";
+        enum __roundl_mangle = "__roundieee128";
+        enum __scalblnl_mangle = "__scalblnieee128";
+        enum __scalbnl_mangle = "__scalbnieee128";
+        enum __sinhl_mangle = "__sinhieee128";
+        enum __sinl_mangle = "__sinieee128";
+        enum __sqrtl_mangle = "__sqrtieee128";
+        enum __tanhl_mangle = "__tanhieee128";
+        enum __tanl_mangle = "__tanieee128";
+        enum __tgammal_mangle = "__tgammaieee128";
+        enum __truncl_mangle = "__truncieee128";
+    }
+    else
+    {
+        enum __acoshl_mangle = "acoshl";
+        enum __acosl_mangle = "acosl";
+        enum __asinhl_mangle = "asinhl";
+        enum __asinl_mangle = "asinl";
+        enum __atan2l_mangle = "atan2l";
+        enum __atanhl_mangle = "atanhl";
+        enum __atanl_mangle = "atanl";
+        enum __cbrtl_mangle = "cbrtl";
+        enum __ceill_mangle = "ceill";
+        enum __copysignl_mangle = "copysignl";
+        enum __coshl_mangle = "coshl";
+        enum __cosl_mangle = "cosl";
+        enum __erfcl_mangle = "erfcl";
+        enum __erfl_mangle = "erfl";
+        enum __exp2l_mangle = "exp2l";
+        enum __expl_mangle = "expl";
+        enum __expm1l_mangle = "expm1l";
+        enum __fabsl_mangle = "fabsl";
+        enum __fdiml_mangle = "fdiml";
+        enum __floorl_mangle = "floorl";
+        enum __fmal_mangle = "fmal";
+        enum __fmaxl_mangle = "fmaxl";
+        enum __fminl_mangle = "fminl";
+        enum __fmodl_mangle = "fmodl";
+        enum __frexpl_mangle = "frexpl";
+        enum __hypotl_mangle = "hypotl";
+        enum __ilogbl_mangle = "ilogbl";
+        enum __ldexpl_mangle = "ldexpl";
+        enum __lgammal_mangle = "lgammal";
+        enum __llrintl_mangle = "llrintl";
+        enum __llroundl_mangle = "llroundl";
+        enum __log10l_mangle = "log10l";
+        enum __log1pl_mangle = "log1pl";
+        enum __log2l_mangle = "log2l";
+        enum __logbl_mangle = "logbl";
+        enum __logl_mangle = "logl";
+        enum __lrintl_mangle = "lrintl";
+        enum __lroundl_mangle = "lroundl";
+        enum __modfl_mangle = "modfl";
+        enum __nanl_mangle = "nanl";
+        enum __nearbyintl_mangle = "nearbyintl";
+        enum __nextafterl_mangle = "nextafterl";
+        enum __nexttoward_mangle = "nexttoward";
+        enum __nexttowardf_mangle = "nexttowardf";
+        enum __nexttowardl_mangle = "nexttowardl";
+        enum __powl_mangle = "powl";
+        enum __remainderl_mangle = "remainderl";
+        enum __remquol_mangle = "remquol";
+        enum __rintl_mangle = "rintl";
+        enum __roundl_mangle = "roundl";
+        enum __scalblnl_mangle = "scalblnl";
+        enum __scalbnl_mangle = "scalbnl";
+        enum __sinhl_mangle = "sinhl";
+        enum __sinl_mangle = "sinl";
+        enum __sqrtl_mangle = "sqrtl";
+        enum __tanhl_mangle = "tanhl";
+        enum __tanl_mangle = "tanl";
+        enum __tgammal_mangle = "tgammal";
+        enum __truncl_mangle = "truncl";
+    }
 }

druntime/src/core/stdc/stdio.d

@@ -1305,6 +1305,7 @@ else version (CRuntime_Glibc)
 {
     ///
     pragma(printf)
+    pragma(mangle, __fprintf_mangle)
     int fprintf(FILE* stream, scope const char* format, scope const ...);
     ///
     pragma(scanf)
@@ -1313,6 +1314,7 @@ else version (CRuntime_Glibc)
     alias fscanf = __isoc99_fscanf;
     ///
     pragma(printf)
+    pragma(mangle, __sprintf_mangle)
     int sprintf(scope char* s, scope const char* format, scope const ...);
     ///
     pragma(scanf)
@@ -1321,6 +1323,7 @@ else version (CRuntime_Glibc)
     alias sscanf = __isoc99_sscanf;
     ///
     pragma(printf)
+    pragma(mangle, __vfprintf_mangle)
     int vfprintf(FILE* stream, scope const char* format, va_list arg);
     ///
     pragma(scanf)
@@ -1329,6 +1332,7 @@ else version (CRuntime_Glibc)
     alias vfscanf = __isoc99_vfscanf;
     ///
     pragma(printf)
+    pragma(mangle, __vsprintf_mangle)
     int vsprintf(scope char* s, scope const char* format, va_list arg);
     ///
     pragma(scanf)
@@ -1337,6 +1341,7 @@ else version (CRuntime_Glibc)
     alias vsscanf = __isoc99_vsscanf;
     ///
     pragma(printf)
+    pragma(mangle, __vprintf_mangle)
     int vprintf(scope const char* format, va_list arg);
     ///
     pragma(scanf)
@@ -1345,12 +1350,32 @@ else version (CRuntime_Glibc)
     alias vscanf = __isoc99_vscanf;
     ///
     pragma(printf)
+    pragma(mangle, __printf_mangle)
     int printf(scope const char* format, scope const ...);
     ///
     pragma(scanf)
     int __isoc99_scanf(scope const char* format, scope ...);
     ///
     alias scanf = __isoc99_scanf;
+
+    version (D_PPCUseIEEE128)
+    {
+        enum __fprintf_mangle = "__fprintfieee128";
+        enum __printf_mangle = "__printfieee128";
+        enum __sprintf_mangle = "__sprintfieee128";
+        enum __vfprintf_mangle = "__vfprintfieee128";
+        enum __vprintf_mangle = "__vprintfieee128";
+        enum __vsprintf_mangle = "__vsprintfieee128";
+    }
+    else
+    {
+        enum __fprintf_mangle = "fprintf";
+        enum __printf_mangle = "printf";
+        enum __sprintf_mangle = "sprintf";
+        enum __vfprintf_mangle = "vfprintf";
+        enum __vprintf_mangle = "vprintf";
+        enum __vsprintf_mangle = "vsprintf";
+    }
 }
 else
 {

druntime/src/core/stdc/stdlib.d

@@ -148,7 +148,17 @@ version (CRuntime_Microsoft)
 else
 {
     /// Added to Bionic since Lollipop.
+    pragma(mangle, __strtold_mangle)
     real strtold(scope inout(char)* nptr, scope inout(char)** endptr);
+
+    version (D_PPCUseIEEE128)
+    {
+        enum __strtold_mangle = "__strtoieee128";
+    }
+    else
+    {
+        enum __strtold_mangle = "strtold";
+    }
 }
 
 // No unsafe pointer manipulation.