Canonicalise Windows target triple spellings

[abdulras]

Summary

Construct a uniform Windows target triple nomenclature which is congruent to the
Linux counterpart. The old triples are normalised to the new canonical form.
This cleans up the long-standing issue of odd naming for various Windows
environments.

There are four different environments on Windows:

MSVC: The MS ABI, MSVCRT environment as defined by Microsoft
GNU: The MinGW32/MinGW32-W64 environment which uses MSVCRT and auxiliary libraries
Itanium: The MSVCRT environment + libc++ built with Itanium ABI
Cygnus: The Cygwin environment which uses custom libraries for everything

The following spellings are now written as:

i686-pc-win32 => i686-pc-windows-msvc
i686-pc-mingw32 => i686-pc-windows-gnu
i686-pc-cygwin => i686-pc-windows-cygnus

This should be sufficiently flexible to allow us to target other windows
environments in the future as necessary.

[rnk]

This seems like the right direction, but we need to stage this so that we don't break Clang.

include/llvm/ADT/Triple.h

334

Are you planning to remove the MinGW32 OS enum?

lib/Support/Triple.cpp

531–539

These canonicalizations will change the behavior of Clang, because it often looks for getOS() == llvm::Triple::MinGW32 / Cygwin in many places. Can we defer this canonicalization until we've updated clang to do the right thing with the new triple?

[chapuni]

"Cygnus" is really odd for me.

I prefer win32 rather than windows.

[rnk]

lgtm

re: cygnus, I guess we could spell it i686--windows-cygwin, but that'd make parsing a little ambiguous. We will always accept i686--cygwin, which is what users will probably keep writing anyway.

Internally, we can't name the environment enum Cygwin until we remove the Cygwin from the OS enum.

lib/Target/X86/X86Subtarget.h

346–360

I'd make these Triple methods, but try to make the naming consistent with the other Triple methods, and then use that in various places.

[abdulras]

Committed with the suggested changes.

include/llvm/ADT/Triple.h

     EABI,
     EABIHF,
     Android,
+
+    MSVC,
+    Itanium,
+    Cygnus,
   };
   enum ObjectFormatType {
     UnknownObjectFormat,

 
   /// \brief Tests for either Cygwin or MinGW OS
   bool isOSCygMing() const {
-    return getOS() == Triple::Cygwin || getOS() == Triple::MinGW32;
+    return getOS() == Triple::Cygwin || getOS() == Triple::MinGW32 ||
+           (getOS() == Triple::Win32 && (getEnvironment() == Triple::Cygnus ||
+                                         getEnvironment() == Triple::GNU));
   }
 
   /// \brief Is this a "Windows" OS targeting a "MSVCRT.dll" environment.

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

   }
 
   if (MAI->doesSupportDebugInformation()) {
-    if (Triple(TM.getTargetTriple()).getOS() == Triple::Win32) {
+    if (Triple(TM.getTargetTriple()).getOS() == Triple::Win32 &&
+        Triple(TM.getTargetTriple()).getEnvironment() == Triple::MSVC) {
       Handlers.push_back(HandlerInfo(new WinCodeViewLineTables(this),
                                      DbgTimerName,
                                      CodeViewLineTablesGroupName));

lib/MC/MCObjectFileInfo.cpp

                         COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
                         COFF::IMAGE_SCN_MEM_READ,
                         SectionKind::getReadOnly());
-  if (T.getOS() == Triple::Win32) {
+  if (T.getOS() == Triple::Win32 && T.getEnvironment() == Triple::MSVC) {
     StaticCtorSection =
       Ctx->getCOFFSection(".CRT$XCU",
                           COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |

   }
 
 
-  if (T.getOS() == Triple::Win32) {
+  if (T.getOS() == Triple::Win32 && T.getEnvironment() == Triple::MSVC) {
     StaticDtorSection =
       Ctx->getCOFFSection(".CRT$XTX",
                           COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |

lib/Support/Triple.cpp

   case NetBSD: return "netbsd";
   case OpenBSD: return "openbsd";
   case Solaris: return "solaris";
-  case Win32: return "win32";
+  case Win32: return "windows";
   case Haiku: return "haiku";
   case Minix: return "minix";
   case RTEMS: return "rtems";

   case EABI: return "eabi";
   case EABIHF: return "eabihf";
   case Android: return "android";
+  case MSVC: return "msvc";
+  case Itanium: return "itanium";
+  case Cygnus: return "cygnus";
   }
 
   llvm_unreachable("Invalid EnvironmentType!");

     .StartsWith("openbsd", Triple::OpenBSD)
     .StartsWith("solaris", Triple::Solaris)
     .StartsWith("win32", Triple::Win32)
+    .StartsWith("windows", Triple::Win32)
     .StartsWith("haiku", Triple::Haiku)
     .StartsWith("minix", Triple::Minix)
     .StartsWith("rtems", Triple::RTEMS)

     .StartsWith("code16", Triple::CODE16)
     .StartsWith("gnu", Triple::GNU)
     .StartsWith("android", Triple::Android)
+    .StartsWith("msvc", Triple::MSVC)
+    .StartsWith("itanium", Triple::Itanium)
+    .StartsWith("cygnus", Triple::Cygnus)
     .Default(Triple::UnknownEnvironment);
 }
 

   EnvironmentType Environment = UnknownEnvironment;
   if (Components.size() > 3)
     Environment = parseEnvironment(Components[3]);
+  ObjectFormatType Format = UnknownObjectFormat;
 
   // Note which components are already in their final position.  These will not
   // be moved.

         Environment = parseEnvironment(Comp);
         Valid = Environment != UnknownEnvironment;
         if (!Valid) {
-          Triple::ObjectFormatType Format = parseFormat(Comp);
+          Format = parseFormat(Comp);
           Valid = Format != UnknownObjectFormat;
         }
         break;

   // Special case logic goes here.  At this point Arch, Vendor and OS have the
   // correct values for the computed components.
 
+  if (OS == Triple::Win32) {
+    Components.resize(4);
+    Components[2] = "windows";
+    if (Environment == UnknownEnvironment && Format == UnknownObjectFormat)
+      Components[3] = "msvc";
+  } else if (OS == Triple::MinGW32) {
+    Components.resize(4);
+    Components[2] = "windows";
+    Components[3] = (Format == Triple::ELF) ? "gnuelf" : "gnu";
+  } else if (OS == Triple::Cygwin) {
+    Components.resize(4);
+    Components[2] = "windows";
+    Components[3] = "cygnus";
+  }
+
   // Stick the corrected components back together to form the normalized string.
   std::string Normalized;
   for (unsigned i = 0, e = Components.size(); i != e; ++i) {

lib/Target/TargetLibraryInfo.cpp

     TLI.setUnavailable(LibFunc::fiprintf);
   }
 
-  if (T.getOS() == Triple::Win32) {
+  if (T.getOS() == Triple::Win32 && T.getEnvironment() == Triple::MSVC) {
     // Win32 does not support long double
     TLI.setUnavailable(LibFunc::acosl);
     TLI.setUnavailable(LibFunc::asinl);

lib/Target/X86/X86Subtarget.h

   bool isTargetNaCl() const { return TargetTriple.isOSNaCl(); }
   bool isTargetNaCl32() const { return isTargetNaCl() && !is64Bit(); }
   bool isTargetNaCl64() const { return isTargetNaCl() && is64Bit(); }
-  bool isTargetWindows() const { return TargetTriple.getOS() == Triple::Win32; }
-  bool isTargetMingw() const { return TargetTriple.getOS() == Triple::MinGW32; }
-  bool isTargetCygwin() const { return TargetTriple.getOS() == Triple::Cygwin; }
+  bool isTargetWindows() const {
+    return TargetTriple.getOS() == Triple::Win32 &&
+           TargetTriple.getEnvironment() != Triple::GNU;
+  }
+  bool isTargetMingw() const {
+    return TargetTriple.getOS() == Triple::MinGW32 ||
+           (TargetTriple.getOS() == Triple::Win32 &&
+            (TargetTriple.getEnvironment() == Triple::Cygnus ||
+             TargetTriple.getEnvironment() == Triple::GNU));
+  }
+  bool isTargetCygwin() const {
+    return TargetTriple.getOS() == Triple::Cygwin ||
+           (TargetTriple.getOS() == Triple::Win32 &&
+            TargetTriple.getEnvironment() == Triple::Cygnus);
+  }
   bool isTargetCygMing() const { return TargetTriple.isOSCygMing(); }
 
   bool isOSWindows() const { return TargetTriple.isOSWindows(); }

unittests/ADT/TripleTest.cpp

          ++Vendor) {
       C[1] = Triple::getVendorTypeName(Triple::VendorType(Vendor));
       for (int OS = 1+Triple::UnknownOS; OS <= Triple::Minix; ++OS) {
+        if (OS == Triple::Cygwin || OS == Triple::MinGW32 || OS == Triple::Win32)
+          continue;
+
         C[2] = Triple::getOSTypeName(Triple::OSType(OS));
 
         std::string E = Join(C[0], C[1], C[2]);

 
   // 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("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((unsigned)0, Micro);
 }
 
+TEST(TripleTest, NormalizeWindows) {
+  EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-win32"));
+  EXPECT_EQ("i686--windows-msvc", Triple::normalize("i686-win32"));
+  EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32"));
+  EXPECT_EQ("i686--windows-gnu", Triple::normalize("i686-mingw32"));
+  EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32-w64"));
+  EXPECT_EQ("i686--windows-gnu", Triple::normalize("i686-mingw32-w64"));
+  EXPECT_EQ("i686-pc-windows-cygnus", Triple::normalize("i686-pc-cygwin"));
+  EXPECT_EQ("i686--windows-cygnus", Triple::normalize("i686-cygwin"));
+
+  EXPECT_EQ("x86_64-pc-windows-msvc", Triple::normalize("x86_64-pc-win32"));
+  EXPECT_EQ("x86_64--windows-msvc", Triple::normalize("x86_64-win32"));
+  EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32"));
+  EXPECT_EQ("x86_64--windows-gnu", Triple::normalize("x86_64-mingw32"));
+  EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32-w64"));
+  EXPECT_EQ("x86_64--windows-gnu", Triple::normalize("x86_64-mingw32-w64"));
+
+  EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-win32-elf"));
+  EXPECT_EQ("i686--windows-elf", Triple::normalize("i686-win32-elf"));
+  EXPECT_EQ("i686-pc-windows-macho", Triple::normalize("i686-pc-win32-macho"));
+  EXPECT_EQ("i686--windows-macho", Triple::normalize("i686-win32-macho"));
+
+  EXPECT_EQ("x86_64-pc-windows-elf", Triple::normalize("x86_64-pc-win32-elf"));
+  EXPECT_EQ("x86_64--windows-elf", Triple::normalize("x86_64-win32-elf"));
+  EXPECT_EQ("x86_64-pc-windows-macho", Triple::normalize("x86_64-pc-win32-macho"));
+  EXPECT_EQ("x86_64--windows-macho", Triple::normalize("x86_64-win32-macho"));
+
+  EXPECT_EQ("i686-pc-windows-itanium", Triple::normalize("i686-pc-windows-itanium"));
+}
+
 }