updates

Author: tgross35

llvm/include/llvm/IR/RuntimeLibcalls.h

@@ -85,14 +85,6 @@ struct RuntimeLibcallsInfo {
                             LibcallRoutineNames + RTLIB::UNKNOWN_LIBCALL);
   }
 
-  /// Set a specific lowering convention for `fp128` math libcalls.
-  ///
-  /// By default, `fp128` math functions get lowered to the C23 `sinf128`-
-  /// style symbols. This allows overriding with `sinl`-style symbols on
-  /// platforms where `long double` is known to be identical to _Float128.
-  /// versions, e.g. `sinf128`.
-  void setF128LibcallFormat(F128LibcallFormat Format);
-
 private:
   /// Stores the name each libcall.
   const char *LibcallRoutineNames[RTLIB::UNKNOWN_LIBCALL + 1];
@@ -118,6 +110,13 @@ struct RuntimeLibcallsInfo {
   /// Set default libcall names. If a target wants to opt-out of a libcall it
   /// should be placed here.
   void initLibcalls(const Triple &TT);
+
+  /// Set a specific lowering convention for `fp128` math libcalls.
+  ///
+  /// By default, `fp128` math functions get lowered to the C23 `sinf128`-
+  /// style symbols. This allows overriding with `sinl`-style symbols on
+  /// platforms where `long double` is known to be identical to _Float128.
+  void setF128LibcallFormat(F128LibcallFormat Format);
 };
 
 } // namespace RTLIB

llvm/include/llvm/TargetParser/Triple.h

@@ -1243,6 +1243,12 @@ class Triple {
   /// or an invalid version tuple if this triple doesn't have one.
   VersionTuple getMinimumSupportedOSVersion() const;
 
+  /// Check whether (1) `f128` is the same format as `long double`, and (2)
+  /// `*f128` symbols are not available. In other words platforms for which
+  /// this returns true may safely use `sqrtl` instead of `sqrtf128`, and
+  /// should do so because `sqrtf128` isn't expected to be available.
+  bool shouldLowerf128AsLongDouble() const;
+
   /// @}
   /// @name Static helpers for IDs.
   /// @{

llvm/lib/IR/RuntimeLibcalls.cpp

@@ -205,6 +205,14 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT) {
     }
     setLibcallName(RTLIB::MULO_I128, nullptr);
   }
+
+  // By default, `fp128` libcalls get lowered to `*f128` symbols, which is
+  // safest because the symbols are only ever for binary128 on all platforms.
+  // Unfortunately many platforms only have the `*l` (`long double`) symbols,
+  // which vary by architecture and compilation flags, so we have to use them
+  // sometimes.
+  if(TT.shouldLowerf128AsLongDouble())
+    setF128LibcallFormat(F128LibcallFormat::LongDouble);
 }
 
 void RuntimeLibcallsInfo::setF128LibcallFormat(F128LibcallFormat Format) {

llvm/lib/TargetParser/Triple.cpp

@@ -2173,6 +2173,43 @@ VersionTuple Triple::getCanonicalVersionForOS(OSType OSKind,
   }
 }
 
+bool Triple::shouldLowerf128AsLongDouble() const {
+  // Always prefer to lower to `*f128` symbols when they are likely to be
+  // available, to avoid any inaccuracies or problems from libc config.
+  //
+  // Note that the logic should be kept in sync with Clang's LongDoubleFormat.
+
+  // Glibc helpfully aliases `*f128` symbols to `*l` symbols on platforms where
+  // that works, so use those.
+  if (isGNUEnvironment())
+    return false;
+  
+  // Windows and Apple always use f64 as `long double`.
+  if (isOSWindows() || isOSDarwin())
+    return false;
+
+  // Most 64-bit architectures use use binary128 on all OSs except Windows and
+  // Apple. A few are binary128 on both 64- and 32-bit.
+  if (isAArch64() || isLoongArch() || isRISCV() || isSPARC() || isSystemZ() ||
+      isVE() || isWasm())
+    return true;
+
+  // MIPS64 is usually f128, except on FreeBSD-like operating systems. MIPS32
+  // is f128 with N32 but f64 with the O32 ABI. Triple doesn't know about ABI
+  // here, so allow MIPS32 to hit the safer `ld !== f128` default.
+  if (isMIPS64() && !(isOSFreeBSD() || isOSKFreeBSD() || isOSDragonFly()))
+    return true;
+
+  // Android and Ohos use binary128 on x86_64.
+  if (getArch() == Triple::x86_64 && (isAndroid() || isOHOSFamily()))
+    return true;
+
+  // By default, make the safe assumption that `long double !== f128`. This
+  // also catchex x86 (`long double` is x87 `f80`) and PowerPC (`long double`
+  // is `f64` or PPC double-double).
+  return false;
+}
+
 // HLSL triple environment orders are relied on in the front end
 static_assert(Triple::Vertex - Triple::Pixel == 1,
               "incorrect HLSL stage order");