ppc64(le): Add an option to use IEEE long double ABI on Linux

CHANGELOG.md

@@ -7,6 +7,8 @@
 - ldc2.conf: `%%ldcversion%%` placeholder added, allowing to refer to version-specific directories.
 
 #### Platform support
+- Supports LLVM 15 - 19.
+- Initial compiler and runtime support for ppc64 and ppc64le systems that use IEEE 754R 128-bit floating-point as the default 128-bit floating-point format. (#4833)
 
 #### Bug fixes
 - Building multi-file D applications with control-flow protection will no longer cause LDC to throw an internal compiler error. (#4828)

CMakeLists.txt

@@ -277,7 +277,28 @@ if( CMAKE_COMPILER_IS_GNUCXX
 endif()
 # Do not use doubledouble on ppc
 if( CMAKE_SYSTEM_PROCESSOR MATCHES "ppc|powerpc")
-    append("-mlong-double-64" LDC_CXXFLAGS)
+    # this extra test checks if the system uses IEEE 754R long double
+    # if that is supported, then there is no need to turn off 128-bit double type
+    CHECK_CXX_SOURCE_COMPILES(
+        "#include <float.h>\nint main(){static_assert(LDBL_MANT_DIG == 113, \"not IEEE long double\");return 0;}\n"
+        HAS_IEEE_LONG_DOUBLE
+    )
+    CHECK_CXX_SOURCE_COMPILES(
+        "#include <float.h>\nint main(){static_assert(LDBL_MANT_DIG == 106, \"not IBM long double\");return 0;}\n"
+        HAS_IBM_LONG_DOUBLE
+    )
+    if ( HAS_IEEE_LONG_DOUBLE )
+        set(LLVM_CXXFLAGS "${LLVM_CXXFLAGS} -mabi=ieeelongdouble")
+        message(
+            WARNING
+            "Your system defaults to IEEE 128-bit ABI."
+            "You will need to include -mabi=ieeelongdouble (GDMD) or --real-precision=quad (LDC) in DFLAGS."
+            "You need to also make sure your host D libraries are built using IEEE 128-bit ABI."
+        )
+    elseif ( NOT HAS_IBM_LONG_DOUBLE )
+        # usually the case for musl/uclibc
+        set(LLVM_CXXFLAGS "${LLVM_CXXFLAGS} -mlong-double-64")
+    endif()
 endif()
 if(UNIX)
     append("-DLDC_POSIX" LDC_CXXFLAGS)

driver/main.cpp

@@ -681,8 +681,10 @@ void registerPredefinedTargetVersions() {
     VersionCondition::addPredefinedGlobalIdent("PPC64");
     registerPredefinedFloatABI("PPC_SoftFloat", "PPC_HardFloat");
     if (triple.getOS() == llvm::Triple::Linux) {
-      VersionCondition::addPredefinedGlobalIdent(
-          triple.getArch() == llvm::Triple::ppc64 ? "ELFv1" : "ELFv2");
+      const llvm::SmallVector<llvm::StringRef> features{};
+      const std::string abi = getABI(triple, features);
+      VersionCondition::addPredefinedGlobalIdent(abi == "elfv1" ? "ELFv1"
+                                                                : "ELFv2");
     }
     break;
   case llvm::Triple::arm:

gen/abi/ppc64le.cpp

@@ -10,24 +10,84 @@
 // The ABI implementation used for 64 bit little-endian PowerPC targets.
 //
 // The PowerOpen 64bit ELF v2 ABI can be found here:
-// https://members.openpowerfoundation.org/document/dl/576
+// https://files.openpower.foundation/s/cfA2oFPXbbZwEBK/download/64biteflv2abi-v1.5.pdf
 //===----------------------------------------------------------------------===//
 
+#include <llvm/IR/IntrinsicsPowerPC.h>
+
 #include "gen/abi/abi.h"
 #include "gen/abi/generic.h"
 #include "gen/dvalue.h"
+#include "gen/funcgenstate.h"
 #include "gen/irstate.h"
 #include "gen/llvmhelpers.h"
 #include "gen/tollvm.h"
+#include "target.h"
 
 using namespace dmd;
 
+struct LongDoubleRewrite : ABIRewrite {
+  inline bool shouldRewrite(Type *ty) {
+    const auto baseTy = ty->toBasetype()->ty;
+    return baseTy == TY::Tfloat80 || baseTy == TY::Tcomplex80 ||
+           baseTy == TY::Timaginary80;
+  }
+
+  LLValue *put(DValue *dv, bool, bool) override {
+    if (shouldRewrite(dv->type)) {
+      auto *dconst = llvm::dyn_cast<llvm::ConstantFP>(DtoRVal(dv));
+      if (dconst) {
+        // try to CTFE the conversion
+        // (ppc_convert_f128_to_ppcf128 intrinsics do not perform the conversion
+        // during the compile time)
+        bool ignored;
+        auto apfloat = dconst->getValue();
+        apfloat.convert(llvm::APFloat::PPCDoubleDouble(),
+                        llvm::APFloat::rmNearestTiesToEven, &ignored);
+        return llvm::ConstantFP::get(gIR->context(), apfloat);
+      }
+      const auto convertFunc = llvm::Intrinsic::getDeclaration(
+          &gIR->module, llvm::Intrinsic::ppc_convert_f128_to_ppcf128);
+      const auto ret = gIR->funcGen().callOrInvoke(
+          convertFunc, convertFunc->getFunctionType(), {DtoRVal(dv)});
+      return ret;
+    }
+    return DtoRVal(dv);
+  }
+
+  LLValue *getLVal(Type *dty, LLValue *v) override {
+    // inverse operation of method "put"
+    auto dstType = DtoType(dty);
+    if (shouldRewrite(dty) && dstType->isFP128Ty()) {
+      const auto convertFunc = llvm::Intrinsic::getDeclaration(
+          &gIR->module, llvm::Intrinsic::ppc_convert_ppcf128_to_f128);
+      const auto retType = LLType::getFP128Ty(gIR->context());
+      const auto buffer = DtoRawAlloca(retType, 16);
+      const auto ret = gIR->funcGen().callOrInvoke(
+          convertFunc, convertFunc->getFunctionType(), {v});
+      DtoStore(ret, buffer);
+      return buffer;
+    }
+    // dual-ABI situation: if the destination type is already correct, we just store it
+    const auto buffer = DtoRawAlloca(dstType, 16);
+    DtoStore(v, buffer);
+    return buffer;
+  }
+
+  LLType *type(Type *ty) override {
+    return LLType::getPPC_FP128Ty(gIR->context());
+  }
+};
+
 struct PPC64LETargetABI : TargetABI {
   HFVAToArray hfvaToArray;
   CompositeToArray64 compositeToArray64;
   IntegerRewrite integerRewrite;
+  LongDoubleRewrite longDoubleRewrite;
+  bool useIEEE128;
 
-  explicit PPC64LETargetABI() : hfvaToArray(8) {}
+  explicit PPC64LETargetABI()
+      : hfvaToArray(8), useIEEE128(target.RealProperties.mant_dig == 113) {}
 
   bool passByVal(TypeFunction *, Type *t) override {
     t = t->toBasetype();
@@ -51,9 +111,11 @@ struct PPC64LETargetABI : TargetABI {
       } else {
         compositeToArray64.applyTo(arg);
       }
-    } else if (ty->isintegral()) {
+    } else if (ty->isintegral() && !ty->isTypeVector()) {
       arg.attrs.addAttribute(ty->isunsigned() ? LLAttribute::ZExt
                                               : LLAttribute::SExt);
+    } else if (!useIEEE128 && longDoubleRewrite.shouldRewrite(arg.type)) {
+      longDoubleRewrite.applyTo(arg);
     }
   }
 };

gen/modules.cpp

@@ -22,6 +22,7 @@
 #include "dmd/statement.h"
 #include "dmd/target.h"
 #include "dmd/template.h"
+#include "driver/cl_options.h"
 #include "driver/cl_options_instrumentation.h"
 #include "driver/timetrace.h"
 #include "gen/abi/abi.h"
@@ -404,6 +405,23 @@ void addModuleFlags(llvm::Module &m) {
       opts::fCFProtection == opts::CFProtectionType::Full) {
     m.setModuleFlag(ModuleMinFlag, "cf-protection-branch", ConstantOneMetadata);
   }
+
+  // Target specific flags
+  const auto ModuleErrFlag = llvm::Module::Error;
+  switch (global.params.targetTriple->getArch()) {
+  case llvm::Triple::ppc64:
+  case llvm::Triple::ppc64le:
+    if (target.RealProperties.mant_dig == 113) {
+      const auto ConstantIEEE128String = llvm::MDString::get(gIR->context(), "ieeequad");
+      m.setModuleFlag(ModuleErrFlag, "float-abi", ConstantIEEE128String);
+    } else {
+      const auto ConstantIBM128String = llvm::MDString::get(gIR->context(), "doubledouble");
+      m.setModuleFlag(ModuleErrFlag, "float-abi", ConstantIBM128String);
+    }
+    break;
+  default:
+    break;
+  }
 }
 
 } // anonymous namespace

gen/target.cpp

@@ -26,13 +26,31 @@
 using namespace dmd;
 using llvm::APFloat;
 
+enum class RealTypeEncoding : uint8_t { Double, IEEEQuad, Platform };
+static llvm::cl::opt<RealTypeEncoding, false> realTypeEncoding{
+    "real-precision", llvm::cl::ZeroOrMore,
+    llvm::cl::init(RealTypeEncoding::Platform),
+    llvm::cl::desc("Set the precision of the `real` type"),
+    llvm::cl::values(
+        clEnumValN(RealTypeEncoding::Double, "double",
+                   "Use double precision (64-bit)"),
+        clEnumValN(RealTypeEncoding::IEEEQuad, "quad",
+                   "Use IEEE quad precision (128-bit)"),
+        clEnumValN(RealTypeEncoding::Platform, "platform",
+                   "Use platform-specific precision (target-specific)"))};
+
 namespace {
 // Returns the LL type to be used for D `real` (C `long double`).
 llvm::Type *getRealType(const llvm::Triple &triple) {
   using llvm::Triple;
 
   auto &ctx = getGlobalContext();
 
+  // If user specified double precision, use it unconditionally.
+  if (realTypeEncoding == RealTypeEncoding::Double) {
+    return LLType::getDoubleTy(ctx);
+  }
+
   // Android: x86 targets follow ARM, with emulated quad precision for x64
   if (triple.getEnvironment() == llvm::Triple::Android) {
     return triple.isArch64Bit() ? LLType::getFP128Ty(ctx)
@@ -64,9 +82,20 @@ llvm::Type *getRealType(const llvm::Triple &triple) {
   case Triple::wasm64:
     return LLType::getFP128Ty(ctx);
 
+  case Triple::ppc64:
+  case Triple::ppc64le:
+    if (triple.isMusl()) { // Musl uses double
+      return LLType::getDoubleTy(ctx);
+    }
+    // dual-ABI complications: PPC only has IEEE 128-bit quad precision on
+    // Linux, IBM double-double is available on both AIX and Linux.
+    return triple.isOSLinux() && realTypeEncoding == RealTypeEncoding::IEEEQuad
+               ? LLType::getFP128Ty(ctx)
+               : LLType::getPPC_FP128Ty(ctx);
+
   default:
     // 64-bit double precision for all other targets
-    // FIXME: PowerPC, SystemZ, ...
+    // FIXME: SystemZ, ...
     return LLType::getDoubleTy(ctx);
   }
 }
@@ -99,6 +128,20 @@ void Target::_init(const Param &params) {
     os = OS_Freestanding;
   }
 
+  if (triple.isPPC64() && realTypeEncoding == RealTypeEncoding::IEEEQuad) {
+    if (triple.isGNUEnvironment()) {
+      // Only GLibc needs this for IEEELongDouble
+      if (!triple.isLittleEndian()) {
+        warning(Loc(), "float ABI 'ieeelongdouble' is not well-supported "
+                       "on big-endian POWER systems");
+      }
+    } else {
+      warning(
+          Loc(),
+          "float ABI 'ieeelongdouble' is not supported by the target system");
+    }
+  }
+
   osMajor = triple.getOSMajorVersion();
 
   ptrsize = gDataLayout->getPointerSize();
@@ -156,6 +199,7 @@ void Target::_init(const Param &params) {
   const auto IEEEdouble = &APFloat::IEEEdouble();
   const auto x87DoubleExtended = &APFloat::x87DoubleExtended();
   const auto IEEEquad = &APFloat::IEEEquad();
+  const auto PPCDoubleDouble = &APFloat::PPCDoubleDouble();
   bool isOutOfRange = false;
 
   RealProperties.nan = CTFloat::nan;
@@ -197,6 +241,18 @@ void Target::_init(const Param &params) {
     RealProperties.min_exp = -16381;
     RealProperties.max_10_exp = 4932;
     RealProperties.min_10_exp = -4931;
+  } else if (targetRealSemantics == PPCDoubleDouble) {
+    RealProperties.max =
+        CTFloat::parse("0x1.fffffffffffff7ffffffffffff8p1023", isOutOfRange);
+    RealProperties.min_normal = CTFloat::parse("0x1p-969", isOutOfRange);
+    RealProperties.epsilon =
+        CTFloat::parse("0x0.000000000000000000000000008p-969", isOutOfRange);
+    RealProperties.dig = 31;
+    RealProperties.mant_dig = 106;
+    RealProperties.max_exp = 1024;
+    RealProperties.min_exp = -968;
+    RealProperties.max_10_exp = 308;
+    RealProperties.min_10_exp = -291;
   } else {
     // leave initialized with host real_t values
     warning(Loc(), "unknown properties for target `real` type, relying on D "
@@ -240,6 +296,19 @@ const char *TargetCPP::typeMangle(Type *t) {
     // `long double` on Android/x64 is __float128 and mangled as `g`
     bool isAndroidX64 = triple.getEnvironment() == llvm::Triple::Android &&
                         triple.getArch() == llvm::Triple::x86_64;
+    if (triple.getArch() == llvm::Triple::ppc64 ||
+        triple.getArch() == llvm::Triple::ppc64le) {
+      if (target.RealProperties.mant_dig == 113 &&
+          triple.getEnvironment() == llvm::Triple::GNU) {
+        return "u9__ieee128";
+      }
+      if (target.RealProperties.mant_dig == 106) {
+        // IBM long double
+        return "g";
+      }
+      // fall back to 64-bit double type
+      return "e";
+    }
     return isAndroidX64 ? "g" : "e";
   }
   return nullptr;

gen/toir.cpp

@@ -1858,8 +1858,8 @@ class ToElemVisitor : public Visitor {
 
     LLValue *b = DtoRVal(DtoCast(e->loc, u, Type::tbool));
 
-    LLConstant *zero = DtoConstBool(false);
-    b = p->ir->CreateICmpEQ(b, zero);
+    LLConstant *one = DtoConstBool(true);
+    b = p->ir->CreateXor(b, one);
 
     result = zextBool(b, e->type);
   }

ldc2.conf.in

@@ -34,6 +34,13 @@ default:
     rpath = "@SHARED_LIBS_RPATH@";
 };
 
+"^powerpc64le-.*linux-gnu$":
+{
+    // default to IEEE quad precision
+    // if your platform does not support this, feel free to remove it.
+    switches = ["--real-precision=quad"]
+};
+
 "^wasm(32|64)-":
 {
     switches = [

ldc2_install.conf.in

@@ -32,6 +32,13 @@ default:
     rpath = "@SHARED_LIBS_INSTALL_RPATH@";
 };
 
+"^powerpc64le-.*linux-gnu$":
+{
+    // default to IEEE quad precision
+    // if your platform does not support this, feel free to remove it.
+    switches = ["--real-precision=quad"]
+};
+
 "^wasm(32|64)-":
 {
     switches = [

ldc2_phobos.conf.in

@@ -35,6 +35,13 @@ default:
     rpath = "@SHARED_LIBS_RPATH@";
 };
 
+"^powerpc64le-.*linux-gnu$":
+{
+    // default to IEEE quad precision
+    // if your platform does not support this, feel free to remove it.
+    switches = ["--real-precision=quad"]
+};
+
 "^wasm(32|64)-":
 {
     switches = [

runtime/druntime/src/core/atomic.d

@@ -652,9 +652,13 @@ version (LDC)
     version (D_LP64)
     {
         version (PPC64)
-            enum has128BitCAS = false;
+        {
+            enum has128BitCAS = real.mant_dig == 113;
+        }
         else
+        {
             enum has128BitCAS = true;
+        }
     }
     else
         enum has128BitCAS = false;

runtime/druntime/src/core/stdc/config.d

@@ -651,3 +651,8 @@ package(core) template muslRedirTime64Mangle(string name, string redirectedName)
     else
         enum muslRedirTime64Mangle = name;
 }
+
+version (PPC64)
+    enum PPCUseIEEE128 = real.mant_dig == 113;
+else
+    enum PPCUseIEEE128 = false;