update

Author: tgross35

clang/lib/Basic/Targets.cpp

@@ -124,7 +124,8 @@ std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple,
     return std::make_unique<XCoreTargetInfo>(Triple, Opts);
 
   case llvm::Triple::hexagon:
-    if (os == llvm::Triple::Linux && Triple.isMusl())
+    if (os == llvm::Triple::Linux &&
+        Triple.getEnvironment() == llvm::Triple::Musl)
       return std::make_unique<LinuxTargetInfo<HexagonTargetInfo>>(Triple, Opts);
     return std::make_unique<HexagonTargetInfo>(Triple, Opts);
 

clang/lib/Driver/Driver.cpp

@@ -797,7 +797,8 @@ static llvm::Triple computeTargetTriple(const Driver &D,
             Target.getEnvironment() == llvm::Triple::GNUT64 ||
             Target.getEnvironment() == llvm::Triple::GNUABI64)
           Target.setEnvironment(llvm::Triple::GNUABIN32);
-        else if (Target.isMusl())
+        else if (Target.getEnvironment() == llvm::Triple::Musl ||
+                 Target.getEnvironment() == llvm::Triple::MuslABI64)
           Target.setEnvironment(llvm::Triple::MuslABIN32);
       } else if (ABIName == "64") {
         Target = Target.get64BitArchVariant();

llvm/include/llvm/IR/RuntimeLibcalls.h

@@ -14,23 +14,21 @@
 #ifndef LLVM_IR_RUNTIME_LIBCALLS_H
 #define LLVM_IR_RUNTIME_LIBCALLS_H
 
-#include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/Support/AtomicOrdering.h"
-#include "llvm/Target/TargetMachine.h"
 #include "llvm/TargetParser/Triple.h"
 
 namespace llvm {
 
 /// Library names to use for `fp128` libcalls.
-// If needed, this could be extended with a `Quadmath` option for `q`-suffixed
-// `libquadmath` symbols.
 enum class F128LibcallFormat {
   /// C23 `*f128` lowering, e.g. `sinf128`
   Default = 0,
   /// `long double` *l` lowering, e.g. `sinl`.
   LongDouble = 1,
+  // If needed, this could be extended with an option for `q` suffixes from
+  // libquadmath.
 };
 
 namespace RTLIB {

llvm/include/llvm/TargetParser/Triple.h

@@ -1231,10 +1231,10 @@ 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.
+  /// Check whether (1) f128 is the same format as `long double`, and (2)
+  /// `*f128` symbols are likely unavailable. In other words, platforms for
+  /// which this returns true may safely use sqrtl instead of sqrtf128 and
+  /// should do so because sqrtf128 would probably error at link time.
   bool shouldLowerf128AsLongDouble() const;
 
   /// @}

llvm/lib/IR/RuntimeLibcalls.cpp

@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/RuntimeLibcalls.h"
-#include "llvm/Target/TargetMachine.h"
 
 using namespace llvm;
 using namespace RTLIB;
@@ -206,7 +205,7 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT) {
     setLibcallName(RTLIB::MULO_I128, nullptr);
   }
 
-  // By default, `fp128` libcalls get lowered to `*f128` symbols, which is
+  // 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

llvm/lib/Target/Hexagon/HexagonSubtarget.h

@@ -113,7 +113,7 @@ class HexagonSubtarget : public HexagonGenSubtargetInfo {
 
   const Triple &getTargetTriple() const { return TargetTriple; }
   bool isEnvironmentMusl() const {
-    return TargetTriple.isMusl();
+    return TargetTriple.getEnvironment() == Triple::Musl;
   }
 
   /// getInstrItins - Return the instruction itineraries based on subtarget

llvm/lib/TargetParser/Triple.cpp

@@ -2180,8 +2180,8 @@ bool Triple::shouldLowerf128AsLongDouble() const {
   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.
+  // Most 64-bit architectures use use binary128, a few are binary128 on both
+  // 64- and 32-bit.
   if (isAArch64() || isLoongArch() || isRISCV() || isSPARC() || isSystemZ() ||
       isVE() || isWasm())
     return true;
@@ -2197,7 +2197,7 @@ bool Triple::shouldLowerf128AsLongDouble() const {
     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`
+  // also catches x86 (`long double` is x87 `f80`) and PowerPC (`long double`
   // is `f64` or PPC double-double).
   return false;
 }