[Triple] Support parsing Gentoo ARM triples, with hardfloat in vendor

[mgorny]

Summary

Support parsing the Gentoo triples of the from arm*-hardfloat-*-*eabi
where the vendor field is used to indicate hardfloat ABI. The triples
are mapped to a correct *-*eabihf variants.

[rengolin]

Adding Saleem, so he can have a fit about "hardfloat" being a "vendor". :)

[mgorny]

Just in case, I'm not particularly attached to it. Just walking in the dark trying to figure out some clean way forward.

Neither do I support those crazy ideas some Gentoo developers had in the past but I doubt there is a clean way of changing that without throwing interim breakage on people.

[rengolin]

In D27362#612200, @mgorny wrote:

Just in case, I'm not particularly attached to it. Just walking in the dark trying to figure out some clean way forward.

Neither do I support those crazy ideas some Gentoo developers had in the past but I doubt there is a clean way of changing that without throwing interim breakage on people.

Been there...

So, this one is complicated. IIRC, there are other cases where the environment swaps with vendor, and there's some normalisation that happens because of that. I can't remember exactly which one, but there's probably a comment on that file explaining the madness.

If we could make that an environment and swap like it's done, it would be much better. But I don't know if we can then normalise to, say, "arm-linux-hardfloat-gnueabi", which can cause problems, for example, when searching for the linker.

Saleem has a lot more experience with crazy triples than I have, so I'll leave him have a more informed opinion.

cheers,
--renato

[compnerd]

As it is, arm-unknown-linux-gnueabi -mfloat-abi=hard and arm-unknown-linux-gnueabihf have differences. We need to identify the calling convention in the backend when generating calls to builtins. Adding yet another mechanism really complicates the situation.

If really your issue is backwards compatibility ... provide a wrapper that canonicalizes the triple. Its not particularly pretty, but it would allow you to prevent the intermittent break.

include/llvm/ADT/Triple.h

145

Why do these need to be vendors? There already are two different ways to specify the hard float and soft float conventions. Please don't introduce a third.

lib/Support/Triple.cpp

513

What happens if someone wants to vend a Gentoo based OS with hard float?

arm-gentoo_is_broken-hardfloat-linux-gnueabi

Ive complained to steev about this in the past.

[mgorny]

Please don't shoot the messenger. I don't have much influence on ARM in Gentoo, and I'm just trying to get clang finally working for our users. Besides, I'm pretty sure changing CHOST would cause intermittent breakage for our users until they rebuild at least gcc, and a number of other random packages. This is not something that can happen overnight, or that we can expect to be a good idea.

I don't see how a wrapper could help us. If it overrides the triple, clang won't be able to find the relevant gcc install because of triple mismatch…

[mgorny]

As noted on D25686 I'm giving up.

include/llvm/ADT/Triple.h

enum VendorType {
     IBM,
     ImaginationTechnologies,
     MipsTechnologies,
     NVIDIA,
     CSR,
     Myriad,
     AMD,
     Mesa,
-    LastVendorType = Mesa
+    // special values used on Gentoo to indicate ARM softfloat/hardfloat
+    SoftFloat,
+    HardFloat,
+    LastVendorType = HardFloat
   };
   enum OSType {
     UnknownOS,
 
     CloudABI,
     Darwin,
     DragonFly,
     FreeBSD,

lib/Support/Triple.cpp

StringRef Triple::getVendorTypeName(VendorType Kind) {
   case IBM: return "ibm";
   case ImaginationTechnologies: return "img";
   case MipsTechnologies: return "mti";
   case NVIDIA: return "nvidia";
   case CSR: return "csr";
   case Myriad: return "myriad";
   case AMD: return "amd";
   case Mesa: return "mesa";
+  case SoftFloat: return "softfloat";
+  case HardFloat: return "hardfloat";
   }
 
   llvm_unreachable("Invalid VendorType!");
 }
 
 StringRef Triple::getOSTypeName(OSType Kind) {
   switch (Kind) {
   case UnknownOS: return "unknown";
return StringSwitch<Triple::VendorType>(VendorName)
     .Case("ibm", Triple::IBM)
     .Case("img", Triple::ImaginationTechnologies)
     .Case("mti", Triple::MipsTechnologies)
     .Case("nvidia", Triple::NVIDIA)
     .Case("csr", Triple::CSR)
     .Case("myriad", Triple::Myriad)
     .Case("amd", Triple::AMD)
     .Case("mesa", Triple::Mesa)
+    .Case("softfloat", Triple::SoftFloat)
+    .Case("hardfloat", Triple::HardFloat)
     .Default(Triple::UnknownVendor);
 }
 
 static Triple::OSType parseOS(StringRef OSName) {
   return StringSwitch<Triple::OSType>(OSName)
     .StartsWith("cloudabi", Triple::CloudABI)
     .StartsWith("darwin", Triple::Darwin)
     .StartsWith("dragonfly", Triple::DragonFly)
return StringSwitch<Triple::OSType>(OSName)
     .StartsWith("elfiamcu", Triple::ELFIAMCU)
     .StartsWith("tvos", Triple::TvOS)
     .StartsWith("watchos", Triple::WatchOS)
     .StartsWith("mesa3d", Triple::Mesa3D)
     .StartsWith("contiki", Triple::Contiki)
     .Default(Triple::UnknownOS);
 }
 
-static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
-  return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
+static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName,
+                                                Triple::VendorType Vendor) {
+  auto ET = StringSwitch<Triple::EnvironmentType>(EnvironmentName)
     .StartsWith("eabihf", Triple::EABIHF)
     .StartsWith("eabi", Triple::EABI)
     .StartsWith("gnuabi64", Triple::GNUABI64)
     .StartsWith("gnueabihf", Triple::GNUEABIHF)
     .StartsWith("gnueabi", Triple::GNUEABI)
     .StartsWith("gnux32", Triple::GNUX32)
     .StartsWith("code16", Triple::CODE16)
     .StartsWith("gnu", Triple::GNU)
     .StartsWith("android", Triple::Android)
     .StartsWith("musleabihf", Triple::MuslEABIHF)
     .StartsWith("musleabi", Triple::MuslEABI)
     .StartsWith("musl", Triple::Musl)
     .StartsWith("msvc", Triple::MSVC)
     .StartsWith("itanium", Triple::Itanium)
     .StartsWith("cygnus", Triple::Cygnus)
     .StartsWith("amdopencl", Triple::AMDOpenCL)
     .StartsWith("coreclr", Triple::CoreCLR)
     .StartsWith("opencl", Triple::OpenCL)
     .Default(Triple::UnknownEnvironment);
+
+  // Gentoo abuses the vendor field for softfloat/hardfloat ARM
+  // e.g. arm-softfloat-linux-gnueabi, arm-hardfloat-linux-gnueabi
+  if (Vendor == Triple::HardFloat) {
+    switch (ET) {
+      case Triple::EABI:
+        ET = Triple::EABIHF;
+        break;
+      case Triple::GNUEABI:
+        ET = Triple::GNUEABIHF;
+        break;
+      case Triple::MuslEABI:
+        ET = Triple::MuslEABIHF;
+        break;
+      default:
+        break;
+    }
+  }
+
+  return ET;
 }
 
 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
   return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
     .EndsWith("coff", Triple::COFF)
     .EndsWith("elf", Triple::ELF)
     .EndsWith("macho", Triple::MachO)
     .Default(Triple::UnknownObjectFormat);
Triple::Triple(const Twine &Str)
   if (Components.size() > 0) {
     Arch = parseArch(Components[0]);
     SubArch = parseSubArch(Components[0]);
     if (Components.size() > 1) {
       Vendor = parseVendor(Components[1]);
       if (Components.size() > 2) {
         OS = parseOS(Components[2]);
         if (Components.size() > 3) {
-          Environment = parseEnvironment(Components[3]);
+          Environment = parseEnvironment(Components[3], Vendor);
           ObjectFormat = parseFormat(Components[3]);
         }
       }
     }
   }
   if (ObjectFormat == UnknownObjectFormat)
     ObjectFormat = getDefaultFormat(*this);
 }

 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
                const Twine &EnvironmentStr)
     : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
             EnvironmentStr).str()),
       Arch(parseArch(ArchStr.str())),
       SubArch(parseSubArch(ArchStr.str())),
       Vendor(parseVendor(VendorStr.str())),
       OS(parseOS(OSStr.str())),
-      Environment(parseEnvironment(EnvironmentStr.str())),
+      Environment(parseEnvironment(EnvironmentStr.str(), Vendor)),
       ObjectFormat(parseFormat(EnvironmentStr.str())) {
   if (ObjectFormat == Triple::UnknownObjectFormat)
     ObjectFormat = getDefaultFormat(*this);
 }
 
 std::string Triple::normalize(StringRef Str) {
   bool IsMinGW32 = false;
   bool IsCygwin = false;
std::string Triple::normalize(StringRef Str) {
   OSType OS = UnknownOS;
   if (Components.size() > 2) {
     OS = parseOS(Components[2]);
     IsCygwin = Components[2].startswith("cygwin");
     IsMinGW32 = Components[2].startswith("mingw");
   }
   EnvironmentType Environment = UnknownEnvironment;
   if (Components.size() > 3)
-    Environment = parseEnvironment(Components[3]);
+    Environment = parseEnvironment(Components[3], Vendor);
   ObjectFormatType ObjectFormat = UnknownObjectFormat;
   if (Components.size() > 4)
     ObjectFormat = parseFormat(Components[4]);
 
   // Note which components are already in their final position.  These will not
   // be moved.
   bool Found[4];
   Found[0] = Arch != UnknownArch;
for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
         break;
       case 2:
         OS = parseOS(Comp);
         IsCygwin = Comp.startswith("cygwin");
         IsMinGW32 = Comp.startswith("mingw");
         Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
         break;
       case 3:
-        Environment = parseEnvironment(Comp);
+        Environment = parseEnvironment(Comp, Vendor);
         Valid = Environment != UnknownEnvironment;
         if (!Valid) {
           ObjectFormat = parseFormat(Comp);
           Valid = ObjectFormat != UnknownObjectFormat;
         }
         break;
       }
       if (!Valid)

unittests/ADT/TripleTest.cpp

TEST(TripleTest, ParsedIDs) {
   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 
   T = Triple("riscv64-unknown-freebsd");
   EXPECT_EQ(Triple::riscv64, T.getArch());
   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
   EXPECT_EQ(Triple::FreeBSD, T.getOS());
   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 
+  // Triples used for Gentoo ARM targets
+  T = Triple("armv5tel-softfloat-linux-gnueabi");
+  EXPECT_EQ(Triple::arm, T.getArch());
+  EXPECT_EQ(Triple::SoftFloat, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
+
+  T = Triple("armv7a-hardfloat-linux-gnueabi");
+  EXPECT_EQ(Triple::arm, T.getArch());
+  EXPECT_EQ(Triple::HardFloat, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::GNUEABIHF, T.getEnvironment());
+
   T = Triple("huh");
   EXPECT_EQ(Triple::UnknownArch, T.getArch());
 }
 
 static std::string Join(StringRef A, StringRef B, StringRef C) {
   std::string Str = A; Str += '-'; Str += B; Str += '-'; Str += C;
   return Str;
 }