Merge pull request #4840 from kinke/ppc64-d-ieee754-fix-new

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

Author: kinke

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

@@ -275,10 +275,6 @@ if( CMAKE_COMPILER_IS_GNUCXX
     AND CMAKE_C_COMPILER_VERSION VERSION_LESS "4.6.0" )
     append("-mminimal-toc" LDC_CXXFLAGS)
 endif()
-# Do not use doubledouble on ppc
-if( CMAKE_SYSTEM_PROCESSOR MATCHES "ppc|powerpc")
-    append("-mlong-double-64" LDC_CXXFLAGS)
-endif()
 if(UNIX)
     append("-DLDC_POSIX" LDC_CXXFLAGS)
 endif()

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,7 +10,7 @@
 // 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 "gen/abi/abi.h"
@@ -51,7 +51,7 @@ 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);
     }

gen/modules.cpp

@@ -404,6 +404,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 if (target.RealProperties.mant_dig == 106) {
+      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,42 @@
 using namespace dmd;
 using llvm::APFloat;
 
+enum class RealPrecision : uint8_t { Default, Double, Quad, DoubleDouble };
+static llvm::cl::opt<RealPrecision, false> realPrecision{
+    "real-precision",
+    llvm::cl::ZeroOrMore,
+    llvm::cl::Hidden,
+    llvm::cl::init(RealPrecision::Default),
+    llvm::cl::desc("Override the precision of the `real` type"),
+    llvm::cl::values(clEnumValN(RealPrecision::Double, "double",
+                                "Use double precision (64-bit)"),
+                     clEnumValN(RealPrecision::Quad, "quad",
+                                "Use IEEE quad precision (128-bit)"),
+                     clEnumValN(RealPrecision::DoubleDouble, "doubledouble",
+                                "Use IBM double double precision (128-bit)"))};
+
 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 overridden with -real-precision:
+  if (realPrecision == RealPrecision::Double) {
+    return LLType::getDoubleTy(ctx);
+  } else if (realPrecision == RealPrecision::Quad) {
+    return LLType::getFP128Ty(ctx);
+  } else if (realPrecision == RealPrecision::DoubleDouble) {
+    if (triple.getArch() != Triple::ppc64 &&
+        triple.getArch() != Triple::ppc64le) {
+      error(Loc(), "'-real-precision=doubledouble' is only supported for "
+                   "PowerPC64 targets");
+      fatal();
+    }
+    return LLType::getPPC_FP128Ty(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 +93,34 @@ 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);
+    }
+#if defined(__linux__) && defined(__powerpc64__)
+    // for a PowerPC64 Linux build:
+    // default to the C++ host compiler's `long double` ABI when targeting
+    // PowerPC64 (non-musl) Linux
+    if (triple.isOSLinux()) {
+#if __LDBL_MANT_DIG__ == 113
+      return LLType::getFP128Ty(ctx);
+#elif __LDBL_MANT_DIG__ == 106
+      return LLType::getPPC_FP128Ty(ctx);
+#elif __LDBL_MANT_DIG__ == 53
+      return LLType::getDoubleTy(ctx);
+#else
+      static_assert(
+          __LDBL_MANT_DIG__ == 0,
+          "Unexpected C++ 'long double' precision for a PowerPC64 host!");
+#endif
+    }
+#endif
+    return LLType::getPPC_FP128Ty(ctx);
+
   default:
     // 64-bit double precision for all other targets
-    // FIXME: PowerPC, SystemZ, ...
+    // FIXME: SystemZ, ...
     return LLType::getDoubleTy(ctx);
   }
 }
@@ -156,6 +210,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 +252,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 "
@@ -237,11 +304,29 @@ Type *Target::va_listType(const Loc &loc, Scope *sc) {
 const char *TargetCPP::typeMangle(Type *t) {
   if (t->ty == TY::Tfloat80) {
     const auto &triple = *global.params.targetTriple;
+
     // `long double` on Android/x64 is __float128 and mangled as `g`
-    bool isAndroidX64 = triple.getEnvironment() == llvm::Triple::Android &&
-                        triple.getArch() == llvm::Triple::x86_64;
-    return isAndroidX64 ? "g" : "e";
+    if (triple.getEnvironment() == llvm::Triple::Android &&
+        triple.getArch() == llvm::Triple::x86_64 &&
+        target.RealProperties.mant_dig == 113) {
+      return "g";
+    };
+
+    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";
+      }
+    }
+
+    return "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);
   }

runtime/druntime/src/core/atomic.d

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

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;