[PowerPC] Emit warning for ieeelongdouble on older GNU toolchain

[qiucf]

Summary

GCC 12 should have proper support for IEEE-754 compliant 128-bit floating point in libstdc++. So warning is needed when linking against older libstdc++ versions or LLVM libc++.

Glibc starts supporting float128 in both header and libraries since 2.32.

[jsji]

clang/test/Driver/ppc-float-abi-warning.cpp

3

Can we add RUN line to test when we are using libc++?

5

So this assume that all our buildbots are using old glibc? What if we have mixed envs, eg: some with newer glibc?

[qiucf]

Also check glibc version.

[jsji]

LGTM.

[nemanjai]

clang/lib/Driver/ToolChains/PPCLinux.cpp

50

Seems that this will be less frequent than every compiler invocation, so we should probably check this first and early exit if the option isn't specified.

[jwakely]

GCC 12 should have proper support for IEEE-754 compliant 128-bit floating point in libstdc++.

Yes, but it's unconditionally disabled when including the headers with Clang.

[qiucf]

In D112906#3304340, @jwakely wrote:

GCC 12 should have proper support for IEEE-754 compliant 128-bit floating point in libstdc++.

Yes, but it's unconditionally disabled when including the headers with Clang.

Is that because clang lacks something required by this feature? (for example. clang-12 doesn't have __ibm128 and many builtins) If so, clang-14 should have these fixed.

[jwakely]

In D112906#3304925, @qiucf wrote:

Is that because clang lacks something required by this feature? (for example. clang-12 doesn't have __ibm128 and many builtins) If so, clang-14 should have these fixed.

When I implemented the libstdc++ changes Clang didn't have any of your work yet. Now that everything seems to be present, and __LONG_DOUBLE_IEEE128__ and __LONG_DOUBLE_IBM128__ are defined as appropriate, I think I can enable it for clang. I'll look into that tomorrow.

[qiucf]

In D112906#3305014, @jwakely wrote:

In D112906#3304925, @qiucf wrote:

Is that because clang lacks something required by this feature? (for example. clang-12 doesn't have __ibm128 and many builtins) If so, clang-14 should have these fixed.

When I implemented the libstdc++ changes Clang didn't have any of your work yet. Now that everything seems to be present, and __LONG_DOUBLE_IEEE128__ and __LONG_DOUBLE_IBM128__ are defined as appropriate, I think I can enable it for clang. I'll look into that tomorrow.

Thanks! I verified latest LLVM/Clang with latest libstdc++ in some programs and they look okay. If you found any more issues, I still have time to get them fixed in clang 14 rc2.

[tbaeder]

Hi @qiucf,

I'm running into a problem with the testsuite that's caused by this patch. I think the comment from @jsji about newer glibc was never addressed.

When running the testsuite on ppc64le with a glibc newer than 2.34, the the warning mentioned in ppc-float-abi-warning.cpp is not emitted when using libstdc++.

In PPCLinuxToolChain::SupportIEEEFloat128():

bool HasUnsupportedCXXLib =
    ToolChain::GetCXXStdlibType(Args) == CST_Libcxx &&
    GCCInstallation.getVersion().isOlderThan(12, 1, 0);

return GlibcSupportsFloat128(Linux::getDynamicLinker(Args)) &&
       !(D.CCCIsCXX() && HasUnsupportedCXXLib);

When using libstdc++, HasUnsupportedCXXLib will always be false since it's not CST_Libcxx...

I don't understand the HasUnsupportedCXXLib variable tbh, is there a typo in the stdlib check, or in a &&/|| mixup?
Right now it is only true if we're using libc++ and the GCC installation is older than 12.1.0.

I will try one approach in the meantime, but your opinion would be appreciated.

clang/include/clang/Basic/DiagnosticDriverKinds.td

   "argument '%0' requires profile-guided optimization information">,
   InGroup<UnusedCommandLineArgument>;
 def warn_drv_clang_unsupported : Warning<
   "the clang compiler does not support '%0'">;
 def warn_drv_deprecated_arg : Warning<
   "argument '%0' is deprecated, use '%1' instead">, InGroup<Deprecated>;
 def warn_drv_assuming_mfloat_abi_is : Warning<
   "unknown platform, assuming -mfloat-abi=%0">;
+def warn_drv_unsupported_float_abi_by_lib : Warning<
+  "float ABI '%0' is not supported by current library">,
+  InGroup<DiagGroup<"unsupported-abi">>;
 def warn_ignoring_ftabstop_value : Warning<
   "ignoring invalid -ftabstop value '%0', using default value %1">;
 def warn_drv_overriding_flag_option : Warning<
   "overriding '%0' option with '%1'">,
   InGroup<DiagGroup<"overriding-t-option">>;
 def warn_drv_treating_input_as_cxx : Warning<
   "treating '%0' input as '%1' when in C++ mode, this behavior is deprecated">,
   InGroup<Deprecated>;

clang/lib/Driver/ToolChains/PPCLinux.h

 
 namespace clang {
 namespace driver {
 namespace toolchains {
 
 class LLVM_LIBRARY_VISIBILITY PPCLinuxToolChain : public Linux {
 public:
   PPCLinuxToolChain(const Driver &D, const llvm::Triple &Triple,
-                    const llvm::opt::ArgList &Args)
-      : Linux(D, Triple, Args) {}
+                    const llvm::opt::ArgList &Args);
 
   void
   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                             llvm::opt::ArgStringList &CC1Args) const override;
+
+private:
+  bool SupportIEEEFloat128(const Driver &D, const llvm::Triple &Triple,
+                           const llvm::opt::ArgList &Args) const;
 };
 
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_PPC_LINUX_H

clang/lib/Driver/ToolChains/PPCLinux.cpp

 //===-- PPCLinux.cpp - PowerPC ToolChain Implementations --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PPCLinux.h"
 #include "clang/Driver/Driver.h"
+#include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
 using namespace clang::driver::toolchains;
 using namespace llvm::opt;
+using namespace llvm::sys;
+
+// Glibc older than 2.32 doesn't fully support IEEE float128. Here we check
+// glibc version by looking at dynamic linker name.
+static bool GlibcSupportsFloat128(const std::string& Linker) {
+  llvm::SmallVector<char, 16> Path;
+
+  // Resolve potential symlinks to linker.
+  if (fs::real_path(Linker, Path))
+    return false;
+  llvm::StringRef LinkerName =
+      path::filename(llvm::StringRef(Path.data(), Path.size()));
+
+  // Since glibc 2.34, the installed .so file is not symlink anymore. But we can
+  // still safely assume it's newer than 2.32.
+  if (LinkerName.startswith("ld64.so"))
+    return true;
+
+  if (!LinkerName.startswith("ld-2."))
+    return false;
+  unsigned Minor = (LinkerName[5] - '0') * 10 + (LinkerName[6] - '0');
+  if (Minor < 32)
+    return false;
+
+  return true;
+}
+
+PPCLinuxToolChain::PPCLinuxToolChain(const Driver &D,
+                                     const llvm::Triple &Triple,
+                                     const llvm::opt::ArgList &Args)
+    : Linux(D, Triple, Args) {
+  if (!SupportIEEEFloat128(D, Triple, Args)) {
+    if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
+      StringRef ABIName = A->getValue();
+      if (ABIName == "ieeelongdouble")
+        D.Diag(diag::warn_drv_unsupported_float_abi_by_lib) << ABIName;
+    }
+  }
+}
 
 void PPCLinuxToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
                                                   ArgStringList &CC1Args) const {
   if (!DriverArgs.hasArg(clang::driver::options::OPT_nostdinc) &&
       !DriverArgs.hasArg(options::OPT_nobuiltininc)) {
     const Driver &D = getDriver();
     SmallString<128> P(D.ResourceDir);
     llvm::sys::path::append(P, "include", "ppc_wrappers");
     addSystemInclude(DriverArgs, CC1Args, P);
   }
 
   Linux::AddClangSystemIncludeArgs(DriverArgs, CC1Args);
 }
+
+bool PPCLinuxToolChain::SupportIEEEFloat128(
+    const Driver &D, const llvm::Triple &Triple,
+    const llvm::opt::ArgList &Args) const {
+  if (!Triple.isLittleEndian() || !Triple.isPPC64())
+    return false;
+
+  if (Args.hasArg(options::OPT_nostdlib, options::OPT_nostdlibxx))
+    return true;
+
+  bool HasUnsupportedCXXLib =
+      ToolChain::GetCXXStdlibType(Args) == CST_Libcxx &&
+      GCCInstallation.getVersion().isOlderThan(12, 1, 0);
+
+  return GlibcSupportsFloat128(Linux::getDynamicLinker(Args)) &&
+         !(D.CCCIsCXX() && HasUnsupportedCXXLib);
+}

clang/test/Driver/ppc-float-abi-warning.cpp

+// REQUIRES: powerpc-registered-target
+// RUN: %clang -### --driver-mode=g++ -target powerpc64le-linux-gnu %s \
+// RUN:  --gcc-toolchain=%S/Inputs/powerpc64le-linux-gnu-tree/gcc-11.2.0 \
+// RUN:  -mabi=ieeelongdouble -stdlib=libstdc++ 2>&1 | FileCheck %s
+// RUN: %clang -### --driver-mode=g++ -target powerpc64le-linux-gnu %s \
+// RUN:  -mabi=ieeelongdouble -stdlib=libc++ 2>&1 | FileCheck %s
+// RUN: %clang -### --driver-mode=g++ -target powerpc64le-linux-gnu %s\
+// RUN:  -mabi=ieeelongdouble -stdlib=libc++ -Wno-unsupported-abi 2>&1 | \
+// RUN:  FileCheck %s --check-prefix=NOWARN
+
+// CHECK: warning: float ABI 'ieeelongdouble' is not supported by current library
+// NOWARN-NOT: warning: float ABI 'ieeelongdouble' is not supported by current library
+long double foo(long double x) { return x;  }