[Triple] Add method for triple canonicalization

[phosek]

Summary

Today, even with normalization it's still possible to get different string representation for the same triple. Specifically, using the short form <arch>-<os> after normalization returns <arch>--<os> (even though the vendor is correctly recognized as unknown) while <arch>-unknown-<os> gives <arch>-unknown-<os>. There should be a way to produce a single canonical triple variant independent of the input.

This is especially desirable in the Clang driver where triple may be used to specify path on the filesystem for a particular target.

[phosek]

I have also considered just adding a default argument to normalize (e.g. bool Canonicalize = true) would that be more preferable?

[rengolin]

lib/Support/Triple.cpp

916

A canonical representation should not have optional features.

Also, it should actually have 5 fields, including the object format, which is needed by FreeBSD.

[rengolin]

Also, where would this be used?

[phosek]

In D32833#747114, @rengolin wrote:

Also, where would this be used?

The plan was to use this in D32613 in the getTargetDir function to ensure that we always get the same path, no matter whether the user specified the target as <arch>-fuchsia or <arch>-unknown-fuchsia. I can do that transformation in the Fuchsia driver, but there are some other drivers where this might be useful, e.g. https://reviews.llvm.org/diffusion/L/browse/cfe/trunk/lib/Driver/ToolChains/CloudABI.cpp;302457$109, but maybe it'd be better to just put a utility method into a ToolChain class?

[rengolin]

Right, I think this is a useful thing to have, but it needs a better plan.

To solve your other problem, I recommend implementing there, locally, for fucsia.

The triple handling, both in clang and llvm, is really confusing and broken. We already have one canonicalisation process and it clearly doesn't work for all cases, adding a new one won't help.

After you solve the problem for fucsia, you should go on the list and bring a proposal to have a single canonicalisation process and representation (Daniel Sanders and Simon Dardis were working on one, with Eric Christopher's help).

The biggest problem is that there are too many users of the triple and none of them use quite the same things in the same way.

Once we have a consensus on the list, we should be producing patches. Not before.

cheers,
--renato

[phosek]

This is no longer needed.

include/llvm/ADT/Triple.h

public:
   /// nothing better can reasonably be done).  In particular, it handles the
   /// common case in which otherwise valid components are in the wrong order.
   static std::string normalize(StringRef Str);
 
   /// Return the normalized form of this triple's string.
   std::string normalize() const { return normalize(Data); }
 
   /// @}
+  /// @name Canonicalization
+  /// @}
+
+  /// canonicalize - Return the canonical triple form, that is a form where
+  /// each component uses the spelling as defined by Triple rather then passed
+  /// externally.
+  std::string canonicalize() const;
+
+  /// @}
   /// @name Typed Component Access
   /// @{
 
   /// getArch - Get the parsed architecture type of this triple.
   ArchType getArch() const { return Arch; }
 
   /// getSubArch - get the parsed subarchitecture type for this triple.
   SubArchType getSubArch() const { return SubArch; }

lib/Support/Triple.cpp

std::string Triple::normalize(StringRef Str) {
   std::string Normalized;
   for (unsigned i = 0, e = Components.size(); i != e; ++i) {
     if (i) Normalized += '-';
     Normalized += Components[i];
   }
   return Normalized;
 }
 
+std::string Triple::canonicalize() const {
+  SmallString<64> Triple;
+  Triple += getArchTypeName(Arch);
+  Triple += "-";
+  Triple += getVendorTypeName(Vendor);
+  Triple += "-";
+  Triple += getOSTypeName(OS);
+  if (Environment != Triple::UnknownEnvironment) {
+    Triple += "-";
+    Triple += getEnvironmentTypeName(Environment);
+  }
+  return Triple.str();
+}
+
 StringRef Triple::getArchName() const {
   return StringRef(Data).split('-').first;           // Isolate first component
 }
 
 StringRef Triple::getVendorName() const {
   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
   return Tmp.split('-').first;                       // Isolate second component
 }

unittests/ADT/TripleTest.cpp

TEST(TripleTest, Normalization) {
   EXPECT_EQ("i386--windows-gnu", 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
   EXPECT_EQ("arm-none--eabi", Triple::normalize("arm-none-eabi")); // arm-none-eabi
 }
 
+TEST(TripleTest, Canonicalization) {
+  Triple T;
+
+  T.setTriple(Triple::normalize("x86_64-linux-gnu"));
+  EXPECT_EQ(Triple::x86_64, T.getArch());
+  EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::GNU, T.getEnvironment());
+  EXPECT_EQ("x86_64-unknown-linux-gnu", T.canonicalize());
+
+  T.setTriple(Triple::normalize("i386-freebsd"));
+  EXPECT_EQ(Triple::x86, T.getArch());
+  EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
+  EXPECT_EQ(Triple::FreeBSD, T.getOS());
+  EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
+  EXPECT_EQ("i386-unknown-freebsd", T.canonicalize());
+}
+
 TEST(TripleTest, MutateName) {
   Triple T;
   EXPECT_EQ(Triple::UnknownArch, T.getArch());
   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
   EXPECT_EQ(Triple::UnknownOS, T.getOS());
   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 
   T.setArchName("i386");