cleanup

Author: tgross35

clang/lib/Driver/Driver.cpp

@@ -808,9 +808,6 @@ static llvm::Triple computeTargetTriple(const Driver &D,
         else if (Target.getEnvironment() == llvm::Triple::Musl ||
                  Target.getEnvironment() == llvm::Triple::MuslABIN32)
           Target.setEnvironment(llvm::Triple::MuslABI64);
-        else if (Target.getEnvironment() == llvm::Triple::MuslF128 ||
-                 Target.getEnvironment() == llvm::Triple::MuslABIN3F128)
-          Target.setEnvironment(llvm::Triple::MuslABI64F128);
       }
     }
   }

clang/lib/Driver/ToolChains/Arch/LoongArch.cpp

@@ -105,11 +105,9 @@ StringRef loongarch::getLoongArchABI(const Driver &D, const ArgList &Args,
   switch (Triple.getEnvironment()) {
   case llvm::Triple::GNUSF:
   case llvm::Triple::MuslSF:
-  case llvm::Triple::MuslSFF128:
     return IsLA32 ? "ilp32s" : "lp64s";
   case llvm::Triple::GNUF32:
   case llvm::Triple::MuslF32:
-  case llvm::Triple::MuslF32F128:
     return IsLA32 ? "ilp32f" : "lp64f";
   case llvm::Triple::GNUF64:
     // This was originally permitted (and indeed the canonical way) to

clang/lib/Driver/ToolChains/Linux.cpp

@@ -110,18 +110,15 @@ std::string Linux::getMultiarchTriple(const Driver &D,
       return TargetTriple.str();
     case llvm::Triple::GNUSF:
     case llvm::Triple::MuslSF:
-    case llvm::Triple::MuslSFF128:
       FPFlavor = "sf";
       break;
     case llvm::Triple::GNUF32:
     case llvm::Triple::MuslF32:
-    case llvm::Triple::MuslF32F128:
       FPFlavor = "f32";
       break;
     case llvm::Triple::GNU:
     case llvm::Triple::GNUF64:
     case llvm::Triple::Musl:
-    case llvm::Triple::MuslF128:
       // This was going to be "f64" in an earlier Toolchain Conventions
       // revision, but starting from Feb 2023 the F64 ABI variants are
       // unmarked in their canonical forms.

llvm/include/llvm/IR/RuntimeLibcalls.h

@@ -51,9 +51,9 @@ enum Libcall {
 
 /// A simple container for information about the supported runtime calls.
 struct RuntimeLibcallsInfo {
-  /// Default libcalls for the triple. Note that `fixupLibcalls` should also be
-  /// called in order to apply machine-specific and configurable behavior.
-  explicit RuntimeLibcallsInfo(const Triple &TT) { initLibcalls(TT); }
+  explicit RuntimeLibcallsInfo(const Triple &TT) {
+    initLibcalls(TT);
+  }
 
   /// Rename the default libcall routine name for the specified libcall.
   void setLibcallName(RTLIB::Libcall Call, const char *Name) {

llvm/include/llvm/TargetParser/Triple.h

@@ -269,14 +269,6 @@ class Triple {
     MuslF32,        // LoongArch ILP32F/LP64F
     MuslSF,         // LoongArch ILP32S/LP64S
     MuslX32,        // Musl using 32-bit ABI on x86_64
-    // Musl with `*f128` math symbols available (e.g. `sqrtf128` rather than
-    // only `sqrtl`). 32-bit musl variants are excluded sin e `*f128` symbols
-    // are required to use `fp128` at all.
-    MuslF128,
-    MuslABI64F128,
-    MuslF32F128,
-    MuslSFF128,
-
     LLVM,
 
     MSVC,
@@ -835,10 +827,6 @@ class Triple {
            getEnvironment() == Triple::MuslF32 ||
            getEnvironment() == Triple::MuslSF ||
            getEnvironment() == Triple::MuslX32 ||
-           getEnvironment() == Triple::MuslF128 ||
-           getEnvironment() == Triple::MuslABI64F128 ||
-           getEnvironment() == Triple::MuslF32F128 ||
-           getEnvironment() == Triple::MuslSFF128 ||
            getEnvironment() == Triple::OpenHOS || isOSLiteOS();
   }
 

llvm/lib/Target/LoongArch/MCTargetDesc/LoongArchBaseInfo.cpp

@@ -54,12 +54,10 @@ static ABI getTripleABI(const Triple &TT) {
   switch (TT.getEnvironment()) {
   case llvm::Triple::EnvironmentType::GNUSF:
   case llvm::Triple::EnvironmentType::MuslSF:
-  case llvm::Triple::EnvironmentType::MuslSFF128:
     TripleABI = Is64Bit ? ABI_LP64S : ABI_ILP32S;
     break;
   case llvm::Triple::EnvironmentType::GNUF32:
   case llvm::Triple::EnvironmentType::MuslF32:
-  case llvm::Triple::EnvironmentType::MuslF32F128:
     TripleABI = Is64Bit ? ABI_LP64F : ABI_ILP32F;
     break;
   // Let the fallback case behave like {ILP32,LP64}D.

llvm/lib/TargetParser/Triple.cpp

@@ -361,10 +361,6 @@ StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) {
   case MuslSF:
     return "muslsf";
   case MuslX32: return "muslx32";
-  case MuslF128: return "musl_f128";
-  case MuslABI64F128: return "muslabi64_f128";
-  case MuslF32F128: return "muslf32_f128";
-  case MuslSFF128: return "muslsf_f128";
   case Simulator: return "simulator";
   case Pixel: return "pixel";
   case Vertex: return "vertex";
@@ -737,10 +733,6 @@ static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
       .StartsWith("gnut64", Triple::GNUT64)
       .StartsWith("gnu", Triple::GNU)
       .StartsWith("android", Triple::Android)
-      .StartsWith("muslabi64_f128", Triple::MuslABI64F128)
-      .StartsWith("muslf32_f128", Triple::MuslF32F128)
-      .StartsWith("muslsf_f128", Triple::MuslSFF128)
-      .StartsWith("musl_f128", Triple::MuslF128)
       .StartsWith("muslabin32", Triple::MuslABIN32)
       .StartsWith("muslabi64", Triple::MuslABI64)
       .StartsWith("musleabihf", Triple::MuslEABIHF)