Add Hurd OS

[pinotree]

Summary

Add a new Hurd OS for Triple, and recognize it from "gnu0" prefixes
(coming from the typical triple, e.g. "i686-unknown-gnuX.Y").
Recognizing the unversioned OS name "gnu" would create too much
confusion with the "gnu" environment, so that is skipped for now.

Also, tweak the normalization test in TripleTest: avoid checking
permutations of the Hurd OS, as it could be mishandled as environment.

include/llvm/ADT/Triple.h

enum OSType {
     NVCL,       // NVIDIA OpenCL
     AMDHSA,     // AMD HSA Runtime
     PS4,
     ELFIAMCU,
     TvOS,       // Apple tvOS
     WatchOS,    // Apple watchOS
     Mesa3D,
     Contiki,
-    LastOSType = Contiki
+    Hurd,
+    LastOSType = Hurd
   };
   enum EnvironmentType {
     UnknownEnvironment,
 
     GNU,
     GNUABI64,
     GNUEABI,
     GNUEABIHF,

lib/Support/Triple.cpp

StringRef Triple::getOSTypeName(OSType Kind) {
   case NVCL: return "nvcl";
   case AMDHSA: return "amdhsa";
   case PS4: return "ps4";
   case ELFIAMCU: return "elfiamcu";
   case TvOS: return "tvos";
   case WatchOS: return "watchos";
   case Mesa3D: return "mesa3d";
   case Contiki: return "contiki";
+  case Hurd: return "gnu";
   }
 
   llvm_unreachable("Invalid OSType");
 }
 
 StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) {
   switch (Kind) {
   case UnknownEnvironment: return "unknown";
return StringSwitch<Triple::OSType>(OSName)
     .StartsWith("nvcl", Triple::NVCL)
     .StartsWith("amdhsa", Triple::AMDHSA)
     .StartsWith("ps4", Triple::PS4)
     .StartsWith("elfiamcu", Triple::ELFIAMCU)
     .StartsWith("tvos", Triple::TvOS)
     .StartsWith("watchos", Triple::WatchOS)
     .StartsWith("mesa3d", Triple::Mesa3D)
     .StartsWith("contiki", Triple::Contiki)
+    .StartsWith("gnu0", Triple::Hurd)
     .Default(Triple::UnknownOS);
 }
 
 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
   return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
     .StartsWith("eabihf", Triple::EABIHF)
     .StartsWith("eabi", Triple::EABI)
     .StartsWith("gnuabi64", Triple::GNUABI64)

unittests/ADT/TripleTest.cpp

TEST(TripleTest, ParsedIDs) {
   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 
   T = Triple("armv7hl-suse-linux-gnueabi");
   EXPECT_EQ(Triple::arm, T.getArch());
   EXPECT_EQ(Triple::SUSE, T.getVendor());
   EXPECT_EQ(Triple::Linux, T.getOS());
   EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
 
+  T = Triple("i686-unknown-gnu0.9");
+  EXPECT_EQ(Triple::x86, T.getArch());
+  EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
+  EXPECT_EQ(Triple::Hurd, T.getOS());
+  EXPECT_EQ(Triple::UnknownEnvironment, 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;
 }
for (int Vendor = FirstVendorType; Vendor <= Triple::LastVendorType;
     int J[] = {0, 1, 2, 3};
     do {
       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
     } while (std::next_permutation(std::begin(J), std::end(J)));
   }
   for (int OS = FirstOSType; OS <= Triple::LastOSType; ++OS) {
     if (OS == Triple::Win32)
       continue;
+    // We skip the Hurd OS, as permutations of it (whose string is "gnu")
+    // might produce different results than expected -- it could be
+    // misrecognized as environment, when placed as last element in the
+    // permutation.
+    if (OS == Triple::Hurd)
+      continue;
     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
     C[2] = Triple::getOSTypeName(Triple::OSType(OS));
     std::string E = Join(C[0], C[1], C[2]);
     int I[] = {0, 1, 2};
     do {
       EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
     } while (std::next_permutation(std::begin(I), std::end(I)));
     std::string F = Join(C[0], C[1], C[2], C[3]);