Add a 'normalize' method to the Triple class, which takes a mucked up

target triple and straightens it out.  This does less than gcc's script
config.sub, for example it turns i386-mingw32 into i386--mingw32 not
i386-pc-mingw32, but it does a decent job of turning funky triples into
something that the rest of the Triple class can understand.  The plan
is to use this to canonicalize triple's when they are first provided
by users, and have the rest of LLVM only deal with canonical triples.
Once this is done the special case workarounds in the Triple constructor
can be removed, making the class more regular and easier to use.  The
comments and unittests for the Triple class are already adjusted in this
patch appropriately for this brave new world of increased uniformity.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@110909 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 108 insertions, 9 deletions

diff --git a/unittests/ADT/TripleTest.cpp b/unittests/ADT/TripleTest.cpp
index 1a9e81a..067f5e5 100644
--- a/unittests/ADT/TripleTest.cpp
+++ b/unittests/ADT/TripleTest.cpp
@@ -92,18 +92,117 @@ TEST(TripleTest, ParsedIDs) {
 
   T = Triple("huh");
   EXPECT_EQ(Triple::UnknownArch, T.getArch());
+}
 
-  // Two exceptional cases.
+static std::string Join(StringRef A, StringRef B, StringRef C) {
+  std::string Str = A; Str += '-'; Str += B; Str += '-'; Str += C;
+  return Str;
+}
 
-  T = Triple("i386-mingw32");
-  EXPECT_EQ(Triple::x86, T.getArch());
-  EXPECT_EQ(Triple::PC, T.getVendor());
-  EXPECT_EQ(Triple::MinGW32, T.getOS());
+static std::string Join(StringRef A, StringRef B, StringRef C, StringRef D) {
+  std::string Str = A; Str += '-'; Str += B; Str += '-'; Str += C; Str += '-';
+  Str += D; return Str;
+}
 
-  T = Triple("arm-elf");
-  EXPECT_EQ(Triple::arm, T.getArch());
-  EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
-  EXPECT_EQ(Triple::UnknownOS, T.getOS());
+TEST(TripleTest, Normalization) {
+  EXPECT_EQ("", Triple::normalize(""));
+  EXPECT_EQ("-", Triple::normalize("-"));
+  EXPECT_EQ("--", Triple::normalize("--"));
+  EXPECT_EQ("---", Triple::normalize("---"));
+  EXPECT_EQ("----", Triple::normalize("----"));
+
+  EXPECT_EQ("a", Triple::normalize("a"));
+  EXPECT_EQ("a-b", Triple::normalize("a-b"));
+  EXPECT_EQ("a-b-c", Triple::normalize("a-b-c"));
+  EXPECT_EQ("a-b-c-d", Triple::normalize("a-b-c-d"));
+
+  EXPECT_EQ("i386-b-c", Triple::normalize("i386-b-c"));
+  EXPECT_EQ("i386-a-c", Triple::normalize("a-i386-c"));
+  EXPECT_EQ("i386-a-b", Triple::normalize("a-b-i386"));
+
+  EXPECT_EQ("a-pc-c", Triple::normalize("a-pc-c"));
+  EXPECT_EQ("-pc-b-c", Triple::normalize("pc-b-c"));
+  EXPECT_EQ("a-pc-b", Triple::normalize("a-b-pc"));
+
+  EXPECT_EQ("a-b-linux", Triple::normalize("a-b-linux"));
+  EXPECT_EQ("--linux-b-c", Triple::normalize("linux-b-c"));
+  EXPECT_EQ("a--linux-c", Triple::normalize("a-linux-c"));
+
+  EXPECT_EQ("i386-pc-a", Triple::normalize("a-pc-i386"));
+  EXPECT_EQ("i386-pc-", Triple::normalize("-pc-i386"));
+  EXPECT_EQ("-pc-linux-c", Triple::normalize("linux-pc-c"));
+  EXPECT_EQ("-pc-linux", Triple::normalize("linux-pc-"));
+
+  EXPECT_EQ("i386", Triple::normalize("i386"));
+  EXPECT_EQ("-pc", Triple::normalize("pc"));
+  EXPECT_EQ("--linux", Triple::normalize("linux"));
+
+  // Check that normalizing a permutated set of valid components returns a
+  // triple with the unpermuted components.
+  StringRef C[4];
+  C[3] = "environment";
+  for (int Arch = 1+Triple::UnknownArch; Arch < Triple::InvalidArch; ++Arch) {
+    C[0] = Triple::getArchTypeName(Triple::ArchType(Arch));
+    for (int Vendor = 1+Triple::UnknownVendor; Vendor <= Triple::PC;
+         ++Vendor) {
+      C[1] = Triple::getVendorTypeName(Triple::VendorType(Vendor));
+      for (int OS = 1+Triple::UnknownOS; OS <= Triple::Minix; ++OS) {
+        C[2] = Triple::getOSTypeName(Triple::OSType(OS));
+
+        std::string E = Join(C[0], C[1], C[2]);
+        std::string F = Join(C[0], C[1], C[2], C[3]);
+        EXPECT_EQ(E, Triple::normalize(Join(C[0], C[1], C[2])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[0], C[1], C[2], C[3])));
+
+        // If a value has multiple interpretations, then the permutation
+        // test will inevitably fail.  Currently this is only the case for
+        // "psp" which parses as both an architecture and an O/S.
+        if (OS == Triple::Psp)
+          continue;
+
+        EXPECT_EQ(E, Triple::normalize(Join(C[0], C[2], C[1])));
+        EXPECT_EQ(E, Triple::normalize(Join(C[1], C[2], C[0])));
+        EXPECT_EQ(E, Triple::normalize(Join(C[1], C[0], C[2])));
+        EXPECT_EQ(E, Triple::normalize(Join(C[2], C[0], C[1])));
+        EXPECT_EQ(E, Triple::normalize(Join(C[2], C[1], C[0])));
+
+        EXPECT_EQ(F, Triple::normalize(Join(C[0], C[1], C[3], C[2])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[0], C[2], C[3], C[1])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[0], C[2], C[1], C[3])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[0], C[3], C[1], C[2])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[0], C[3], C[2], C[1])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[1], C[2], C[3], C[0])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[1], C[2], C[0], C[3])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[1], C[3], C[0], C[2])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[1], C[3], C[2], C[0])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[1], C[0], C[2], C[3])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[1], C[0], C[3], C[2])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[2], C[3], C[0], C[1])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[2], C[3], C[1], C[0])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[2], C[0], C[1], C[3])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[2], C[0], C[3], C[1])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[2], C[1], C[3], C[0])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[2], C[1], C[0], C[3])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[3], C[0], C[1], C[2])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[3], C[0], C[2], C[1])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[3], C[1], C[2], C[0])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[3], C[1], C[0], C[2])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[3], C[2], C[0], C[1])));
+        EXPECT_EQ(F, Triple::normalize(Join(C[3], C[2], C[1], C[0])));
+      }
+    }
+  }
+
+  EXPECT_EQ("a-b-psp", Triple::normalize("a-b-psp"));
+  EXPECT_EQ("psp-b-c", Triple::normalize("psp-b-c"));
+
+  // Various real-world funky triples.  The value returned by GCC's config.sub
+  // is given in the comment.
+  EXPECT_EQ("i386--mingw32", Triple::normalize("i386-mingw32")); // i386-pc-mingw32
+  EXPECT_EQ("x86_64--linux-gnu", Triple::normalize("x86_64-linux-gnu")); // x86_64-pc-linux-gnu
+  EXPECT_EQ("i486--linux-gnu", Triple::normalize("i486-linux-gnu")); // i486-pc-linux-gnu
+  EXPECT_EQ("i386-redhat-linux", Triple::normalize("i386-redhat-linux")); // i386-redhat-linux-gnu
+  EXPECT_EQ("i686--linux", Triple::normalize("i686-linux")); // i686-pc-linux-gnu
 }
 
 TEST(TripleTest, MutateName) {