[Distro] Bypass distro detection on non-Linux hosts

[aganea]

Summary

This skips distro detection when we're not running on Linux, or when the target triple is not Linux. This saves a few OS calls for each invocation of clang.exe.

[rnk]

I'd rather avoid the ifdef if possible. I looked to see where these come from:

$ git grep -l Distro ../clang/lib/Driver/
../clang/lib/Driver/CMakeLists.txt
../clang/lib/Driver/Distro.cpp
../clang/lib/Driver/ToolChains/Clang.cpp
../clang/lib/Driver/ToolChains/Cuda.cpp
../clang/lib/Driver/ToolChains/Linux.cpp

I think the only one that matters is in Clang.cpp, but it looks like it should never run on Windows:

if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
                 (TC.getTriple().isOSBinFormatELF() ||
                  TC.getTriple().isOSBinFormatCOFF()) &&
                    !TC.getTriple().isPS4() &&
                    !TC.getTriple().isOSNetBSD() &&
                    !Distro(D.getVFS()).IsGentoo() &&
                    !TC.getTriple().isAndroid() &&
                     TC.useIntegratedAs()))
  CmdArgs.push_back("-faddrsig");

Hm, I guess it does happen. I think that condition should be restructured to only do all that BSD, PS4, Android, Gentoo etc logic if the format is ELF, if COFF, then always default to -faddrsig.

[aganea]

In D70467#1752611, @rnk wrote:

Hm, I guess it does happen. I think that condition should be restructured to only do all that BSD, PS4, Android, Gentoo etc logic if the format is ELF, if COFF, then always default to -faddrsig.

We're cross-compiling all our target platforms on Windows. It seems this patch would be still valid in that case:

> clang -target x86_64-linux a.cpp

Would still call DetectDistro(), and unless I'm missing something, we wouldn't want it to lookup C:\etc\lsb-release even if it's there? Or people are really doing that to target a specific distro when compiling from Windows? It doesn't make sense from my POV.
The same argument applies to CUDA: the code in clang/lib/Driver/ToolChains/Cuda.cpp:CudaInstallationDetector() says "HostTriple" but it's actually the Target triple -- you can try my cmd-line above, it hits the Distro detect.
Unless you specify a non-real FS, I wouldn't want DetectDistro to return anything else than Distro::UnknownDistro when running on a non-Linux OS.
Would you have a different opinion or something I don't see?

[aganea]

Actually, I'm not sure the DetectDistro() does what it intends to do when cross-compiling: if I compile on Ubuntu and I forcibly specify -target x86_64-linux on the cmd-line, should it detect which Linux distro I'm on? In the case of CudaInstallationDetector() it seems it should use the host triple, whereas in the case clang/lib/Driver/ToolChains/Linux.cpp:Linux() it adds flags for building the target, so it should take the target triple maybe. Should we pass a triple to DetectDistro?

[aganea]

Removed #ifdef _WIN32
Use the target triple where possible to detect the distro. The Cuda installation detector uses the host triple, in order to use the host tooling.
Skip distro detection when the target or host system is not Linux.

[rnk]

In D70467#1755364, @aganea wrote:

Actually, I'm not sure the DetectDistro() does what it intends to do when cross-compiling: if I compile on Ubuntu and I forcibly specify -target x86_64-linux on the cmd-line, should it detect which Linux distro I'm on? In the case of CudaInstallationDetector() it seems it should use the host triple, whereas in the case clang/lib/Driver/ToolChains/Linux.cpp:Linux() it adds flags for building the target, so it should take the target triple maybe. Should we pass a triple to DetectDistro?

It does seem wrong to use DetectDistro when the user passes a target triple. DetectDistro inherently detects something about that host, and it seems we don't have a way to pass that information explicitly on the command line. So, cross-compiling from one distro to another might somehow do the wrong thing depending on what distro detection does.

In D70467#1755337, @aganea wrote:

In D70467#1752611, @rnk wrote:

Hm, I guess it does happen. I think that condition should be restructured to only do all that BSD, PS4, Android, Gentoo etc logic if the format is ELF, if COFF, then always default to -faddrsig.

We're cross-compiling all our target platforms on Windows. It seems this patch would be still valid in that case:

> clang -target x86_64-linux a.cpp

Would still call DetectDistro(), and unless I'm missing something, we wouldn't want it to lookup C:\etc\lsb-release even if it's there? Or people are really doing that to target a specific distro when compiling from Windows? It doesn't make sense from my POV.
The same argument applies to CUDA: the code in clang/lib/Driver/ToolChains/Cuda.cpp:CudaInstallationDetector() says "HostTriple" but it's actually the Target triple -- you can try my cmd-line above, it hits the Distro detect.
Unless you specify a non-real FS, I wouldn't want DetectDistro to return anything else than Distro::UnknownDistro when running on a non-Linux OS.
Would you have a different opinion or something I don't see?

True, that makes sense to me.

lgtm

clang/lib/Driver/Distro.cpp

29

I think it's worth adding more to this comment. This is the case where someone is cross-compiling from BSD or Windows to Linux, and it would be meaningless to try to figure out the "distro" of the non-Linux host.

clang/lib/Driver/ToolChains/Linux.cpp

514

So many duplicate detections. =/

clang/include/clang/Driver/Distro.h

 //===--- Distro.h - Linux distribution detection support --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_DRIVER_DISTRO_H
 #define LLVM_CLANG_DRIVER_DISTRO_H
 
+#include "llvm/ADT/Triple.h"
 #include "llvm/Support/VirtualFileSystem.h"
 
 namespace clang {
 namespace driver {
 
 /// Distro - Helper class for detecting and classifying Linux distributions.
 ///
 /// This class encapsulates the clang Linux distribution detection mechanism
public:
 
   /// Default constructor leaves the distribution unknown.
   Distro() : DistroVal() {}
 
   /// Constructs a Distro type for specific distribution.
   Distro(DistroType D) : DistroVal(D) {}
 
   /// Detects the distribution using specified VFS.
-  explicit Distro(llvm::vfs::FileSystem &VFS);
+  explicit Distro(llvm::vfs::FileSystem &VFS, const llvm::Triple &TargetOrHost);
 
   bool operator==(const Distro &Other) const {
     return DistroVal == Other.DistroVal;
   }
 
   bool operator!=(const Distro &Other) const {
     return DistroVal != Other.DistroVal;
   }

clang/lib/Driver/Distro.cpp

 //===--- Distro.cpp - Linux distribution detection support ------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Driver/Distro.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/ADT/Triple.h"
 
 using namespace clang::driver;
 using namespace clang;
 
-static Distro::DistroType DetectDistro(llvm::vfs::FileSystem &VFS) {
+static Distro::DistroType DetectDistro(llvm::vfs::FileSystem &VFS,
+                                       const llvm::Triple &TargetOrHost) {
+  // If we don't target Linux, no need to check the distro. This saves a few
+  // OS calls.
+  if (!TargetOrHost.isOSLinux())
+    return Distro::UnknownDistro;
+
+  // If the host is not running Linux, and we're backed by a real file system,
+  // no need to check the distro. This is the case where someone is
+  // cross-compiling from BSD or Windows to Linux, and it would be meaningless
+  // to try to figure out the "distro" of the non-Linux host.
+  IntrusiveRefCntPtr<llvm::vfs::FileSystem> RealFS =
+      llvm::vfs::getRealFileSystem();
+  llvm::Triple HostTriple(llvm::sys::getProcessTriple());
+  if (!HostTriple.isOSLinux() && &VFS == RealFS.get())
+    return Distro::UnknownDistro;
+
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
       VFS.getBufferForFile("/etc/lsb-release");
   if (File) {
     StringRef Data = File.get()->getBuffer();
     SmallVector<StringRef, 16> Lines;
     Data.split(Lines, "\n");
     Distro::DistroType Version = Distro::UnknownDistro;
     for (StringRef Line : Lines)
if (VFS.exists("/etc/arch-release"))
     return Distro::ArchLinux;
 
   if (VFS.exists("/etc/gentoo-release"))
     return Distro::Gentoo;
 
   return Distro::UnknownDistro;
 }
 
-Distro::Distro(llvm::vfs::FileSystem &VFS) : DistroVal(DetectDistro(VFS)) {}
+Distro::Distro(llvm::vfs::FileSystem &VFS, const llvm::Triple &TargetOrHost)
+    : DistroVal(DetectDistro(VFS, TargetOrHost)) {}

clang/lib/Driver/ToolChains/Clang.cpp

if (Arg *A = Args.getLastArg(options::OPT_moutline,
     }
   }
 
   if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
                    (TC.getTriple().isOSBinFormatELF() ||
                     TC.getTriple().isOSBinFormatCOFF()) &&
                       !TC.getTriple().isPS4() &&
                       !TC.getTriple().isOSNetBSD() &&
-                      !Distro(D.getVFS()).IsGentoo() &&
+                      !Distro(D.getVFS(), TC.getTriple()).IsGentoo() &&
                       !TC.getTriple().isAndroid() &&
                        TC.useIntegratedAs()))
     CmdArgs.push_back("-faddrsig");
 
   if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
     std::string Str = A->getAsString(Args);
     if (!TC.getTriple().isOSBinFormatELF())
       D.Diag(diag::err_drv_unsupported_opt_for_target)

clang/lib/Driver/ToolChains/Cuda.cpp

if (!Args.hasArg(clang::driver::options::OPT_cuda_path_ignore_env)) {
                                   /*StrictChecking=*/true);
       }
     }
 
     Candidates.emplace_back(D.SysRoot + "/usr/local/cuda");
     for (const char *Ver : Versions)
       Candidates.emplace_back(D.SysRoot + "/usr/local/cuda-" + Ver);
 
-    if (Distro(D.getVFS()).IsDebian() || Distro(D.getVFS()).IsUbuntu())
+    Distro Dist(D.getVFS(), llvm::Triple(llvm::sys::getProcessTriple()));
+    if (Dist.IsDebian() || Dist.IsUbuntu())
       // Special case for Debian to have nvidia-cuda-toolkit work
       // out of the box. More info on http://bugs.debian.org/882505
       Candidates.emplace_back(D.SysRoot + "/usr/lib/cuda");
   }
 
   bool NoCudaLib = Args.hasArg(options::OPT_nogpulib);
 
   for (const auto &Candidate : Candidates) {

clang/lib/Driver/ToolChains/Linux.cpp

Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
   // FIXME: This seems unlikely to be Linux-specific.
   ToolChain::path_list &PPaths = getProgramPaths();
   if (GCCInstallation.isValid()) {
     PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
                            GCCInstallation.getTriple().str() + "/bin")
                          .str());
   }
 
-  Distro Distro(D.getVFS());
+  Distro Distro(D.getVFS(), Triple);
 
   if (Distro.IsAlpineLinux() || Triple.isAndroid()) {
     ExtraOpts.push_back("-z");
     ExtraOpts.push_back("now");
   }
 
   if (Distro.IsOpenSUSE() || Distro.IsUbuntu() || Distro.IsAlpineLinux() ||
       Triple.isAndroid()) {
std::string Linux::computeSysRoot() const {
 
   return std::string();
 }
 
 std::string Linux::getDynamicLinker(const ArgList &Args) const {
   const llvm::Triple::ArchType Arch = getArch();
   const llvm::Triple &Triple = getTriple();
 
-  const Distro Distro(getDriver().getVFS());
+  const Distro Distro(getDriver().getVFS(), Triple);
 
   if (Triple.isAndroid())
     return Triple.isArch64Bit() ? "/system/bin/linker64" : "/system/bin/linker";
 
   if (Triple.isMusl()) {
     std::string ArchName;
     bool IsArm = false;
 

clang/unittests/Driver/DistroTest.cpp

UbuntuTrustyFileSystem.addFile("/etc/os-release", 0,
                                        "ID=ubuntu\n"
                                        "ID_LIKE=debian\n"
                                        "PRETTY_NAME=\"Ubuntu 14.04 LTS\"\n"
                                        "VERSION_ID=\"14.04\"\n"
                                        "HOME_URL=\"http://www.ubuntu.com/\"\n"
                                        "SUPPORT_URL=\"http://help.ubuntu.com/\"\n"
                                        "BUG_REPORT_URL=\"http://bugs.launchpad.net/ubuntu/\"\n"));
 
-  Distro UbuntuTrusty{UbuntuTrustyFileSystem};
+  Distro UbuntuTrusty{UbuntuTrustyFileSystem, llvm::Triple("unknown-pc-linux")};
   ASSERT_EQ(Distro(Distro::UbuntuTrusty), UbuntuTrusty);
   ASSERT_TRUE(UbuntuTrusty.IsUbuntu());
   ASSERT_FALSE(UbuntuTrusty.IsRedhat());
   ASSERT_FALSE(UbuntuTrusty.IsOpenSUSE());
   ASSERT_FALSE(UbuntuTrusty.IsDebian());
   ASSERT_FALSE(UbuntuTrusty.IsGentoo());
 
+  Distro UbuntuTrusty2{UbuntuTrustyFileSystem, llvm::Triple("unknown-pc-windows")};
+  ASSERT_EQ(Distro(Distro::UnknownDistro), UbuntuTrusty2);
+
   llvm::vfs::InMemoryFileSystem UbuntuYakketyFileSystem;
   UbuntuYakketyFileSystem.addFile("/etc/debian_version", 0,
       llvm::MemoryBuffer::getMemBuffer("stretch/sid\n"));
   UbuntuYakketyFileSystem.addFile("/etc/lsb-release", 0,
       llvm::MemoryBuffer::getMemBuffer("DISTRIB_ID=Ubuntu\n"
                                        "DISTRIB_RELEASE=16.10\n"
                                        "DISTRIB_CODENAME=yakkety\n"
                                        "DISTRIB_DESCRIPTION=\"Ubuntu 16.10\"\n"));
   UbuntuYakketyFileSystem.addFile("/etc/os-release", 0,
       llvm::MemoryBuffer::getMemBuffer("NAME=\"Ubuntu\"\n"
                                        "VERSION=\"16.10 (Yakkety Yak)\"\n"
                                        "ID=ubuntu\n"
                                        "ID_LIKE=debian\n"
                                        "PRETTY_NAME=\"Ubuntu 16.10\"\n"
                                        "VERSION_ID=\"16.10\"\n"
                                        "HOME_URL=\"http://www.ubuntu.com/\"\n"
                                        "SUPPORT_URL=\"http://help.ubuntu.com/\"\n"
                                        "BUG_REPORT_URL=\"http://bugs.launchpad.net/ubuntu/\"\n"
                                        "PRIVACY_POLICY_URL=\"http://www.ubuntu.com/legal/terms-and-policies/privacy-policy\"\n"
                                        "VERSION_CODENAME=yakkety\n"
                                        "UBUNTU_CODENAME=yakkety\n"));
 
-  Distro UbuntuYakkety{UbuntuYakketyFileSystem};
+  Distro UbuntuYakkety{UbuntuYakketyFileSystem, llvm::Triple("unknown-pc-linux")};
   ASSERT_EQ(Distro(Distro::UbuntuYakkety), UbuntuYakkety);
   ASSERT_TRUE(UbuntuYakkety.IsUbuntu());
   ASSERT_FALSE(UbuntuYakkety.IsRedhat());
   ASSERT_FALSE(UbuntuYakkety.IsOpenSUSE());
   ASSERT_FALSE(UbuntuYakkety.IsDebian());
   ASSERT_FALSE(UbuntuYakkety.IsGentoo());
 }
 
Fedora25FileSystem.addFile("/etc/os-release", 0,
                                        "CPE_NAME=\"cpe:/o:fedoraproject:fedora:25\"\n"
                                        "HOME_URL=\"https://fedoraproject.org/\"\n"
                                        "BUG_REPORT_URL=\"https://bugzilla.redhat.com/\"\n"
                                        "REDHAT_BUGZILLA_PRODUCT=\"Fedora\"\n"
                                        "REDHAT_BUGZILLA_PRODUCT_VERSION=25\n"
                                        "REDHAT_SUPPORT_PRODUCT=\"Fedora\"\n"
                                        "REDHAT_SUPPORT_PRODUCT_VERSION=25\n"
                                        "PRIVACY_POLICY_URL=https://fedoraproject.org/wiki/Legal:PrivacyPolicy\n"));
-  Distro Fedora25{Fedora25FileSystem};
+  Distro Fedora25{Fedora25FileSystem, llvm::Triple("unknown-pc-linux")};
   ASSERT_EQ(Distro(Distro::Fedora), Fedora25);
   ASSERT_FALSE(Fedora25.IsUbuntu());
   ASSERT_TRUE(Fedora25.IsRedhat());
   ASSERT_FALSE(Fedora25.IsOpenSUSE());
   ASSERT_FALSE(Fedora25.IsDebian());
   ASSERT_FALSE(Fedora25.IsGentoo());
 
   llvm::vfs::InMemoryFileSystem CentOS7FileSystem;
CentOS7FileSystem.addFile("/etc/os-release", 0,
                                        "HOME_URL=\"https://www.centos.org/\"\n"
                                        "BUG_REPORT_URL=\"https://bugs.centos.org/\"\n"
                                        "\n"
                                        "CENTOS_MANTISBT_PROJECT=\"CentOS-7\"\n"
                                        "CENTOS_MANTISBT_PROJECT_VERSION=\"7\"\n"
                                        "REDHAT_SUPPORT_PRODUCT=\"centos\"\n"
                                        "REDHAT_SUPPORT_PRODUCT_VERSION=\"7\"\n"));
 
-  Distro CentOS7{CentOS7FileSystem};
+  Distro CentOS7{CentOS7FileSystem, llvm::Triple("unknown-pc-linux")};
   ASSERT_EQ(Distro(Distro::RHEL7), CentOS7);
   ASSERT_FALSE(CentOS7.IsUbuntu());
   ASSERT_TRUE(CentOS7.IsRedhat());
   ASSERT_FALSE(CentOS7.IsOpenSUSE());
   ASSERT_FALSE(CentOS7.IsDebian());
   ASSERT_FALSE(CentOS7.IsGentoo());
 }
 
OpenSUSELeap421FileSystem.addFile("/etc/os-release", 0,
                                        "PRETTY_NAME=\"openSUSE Leap 42.1 (x86_64)\"\n"
                                        "ID=opensuse\n"
                                        "ANSI_COLOR=\"0;32\"\n"
                                        "CPE_NAME=\"cpe:/o:opensuse:opensuse:42.1\"\n"
                                        "BUG_REPORT_URL=\"https://bugs.opensuse.org\"\n"
                                        "HOME_URL=\"https://opensuse.org/\"\n"
                                        "ID_LIKE=\"suse\"\n"));
 
-  Distro OpenSUSELeap421{OpenSUSELeap421FileSystem};
+  Distro OpenSUSELeap421{OpenSUSELeap421FileSystem, llvm::Triple("unknown-pc-linux")};
   ASSERT_EQ(Distro(Distro::OpenSUSE), OpenSUSELeap421);
   ASSERT_FALSE(OpenSUSELeap421.IsUbuntu());
   ASSERT_FALSE(OpenSUSELeap421.IsRedhat());
   ASSERT_TRUE(OpenSUSELeap421.IsOpenSUSE());
   ASSERT_FALSE(OpenSUSELeap421.IsDebian());
   ASSERT_FALSE(OpenSUSELeap421.IsGentoo());
 
   llvm::vfs::InMemoryFileSystem OpenSUSE132FileSystem;
OpenSUSE132FileSystem.addFile("/etc/os-release", 0,
                                        "PRETTY_NAME=\"openSUSE 13.2 (Harlequin) (x86_64)\"\n"
                                        "ID=opensuse\n"
                                        "ANSI_COLOR=\"0;32\"\n"
                                        "CPE_NAME=\"cpe:/o:opensuse:opensuse:13.2\"\n"
                                        "BUG_REPORT_URL=\"https://bugs.opensuse.org\"\n"
                                        "HOME_URL=\"https://opensuse.org/\"\n"
                                        "ID_LIKE=\"suse\"\n"));
 
-  Distro OpenSUSE132{OpenSUSE132FileSystem};
+  Distro OpenSUSE132{OpenSUSE132FileSystem, llvm::Triple("unknown-pc-linux")};
   ASSERT_EQ(Distro(Distro::OpenSUSE), OpenSUSE132);
   ASSERT_FALSE(OpenSUSE132.IsUbuntu());
   ASSERT_FALSE(OpenSUSE132.IsRedhat());
   ASSERT_TRUE(OpenSUSE132.IsOpenSUSE());
   ASSERT_FALSE(OpenSUSE132.IsDebian());
   ASSERT_FALSE(OpenSUSE132.IsGentoo());
 
   llvm::vfs::InMemoryFileSystem SLES10FileSystem;
   SLES10FileSystem.addFile("/etc/SuSE-release", 0,
       llvm::MemoryBuffer::getMemBuffer("SUSE Linux Enterprise Server 10 (x86_64)\n"
                                        "VERSION = 10\n"
                                        "PATCHLEVEL = 4\n"));
   SLES10FileSystem.addFile("/etc/lsb_release", 0,
       llvm::MemoryBuffer::getMemBuffer("LSB_VERSION=\"core-2.0-noarch:core-3.0-noarch:core-2.0-x86_64:core-3.0-x86_64\"\n"));
 
   // SLES10 is unsupported and therefore evaluates to unknown
-  Distro SLES10{SLES10FileSystem};
+  Distro SLES10{SLES10FileSystem, llvm::Triple("unknown-pc-linux")};
   ASSERT_EQ(Distro(Distro::UnknownDistro), SLES10);
   ASSERT_FALSE(SLES10.IsUbuntu());
   ASSERT_FALSE(SLES10.IsRedhat());
   ASSERT_FALSE(SLES10.IsOpenSUSE());
   ASSERT_FALSE(SLES10.IsDebian());
   ASSERT_FALSE(SLES10.IsGentoo());
 }
 
 TEST(DistroTest, DetectDebian) {
   llvm::vfs::InMemoryFileSystem DebianJessieFileSystem;
   DebianJessieFileSystem.addFile("/etc/debian_version", 0,
                                  llvm::MemoryBuffer::getMemBuffer("8.6\n"));
   DebianJessieFileSystem.addFile("/etc/os-release", 0,
       llvm::MemoryBuffer::getMemBuffer("PRETTY_NAME=\"Debian GNU/Linux 8 (jessie)\"\n"
                                        "NAME=\"Debian GNU/Linux\"\n"
                                        "VERSION_ID=\"8\"\n"
                                        "VERSION=\"8 (jessie)\"\n"
                                        "ID=debian\n"
                                        "HOME_URL=\"http://www.debian.org/\"\n"
                                        "SUPPORT_URL=\"http://www.debian.org/support\"\n"
                                        "BUG_REPORT_URL=\"https://bugs.debian.org/\"\n"));
 
-  Distro DebianJessie{DebianJessieFileSystem};
+  Distro DebianJessie{DebianJessieFileSystem, llvm::Triple("unknown-pc-linux")};
   ASSERT_EQ(Distro(Distro::DebianJessie), DebianJessie);
   ASSERT_FALSE(DebianJessie.IsUbuntu());
   ASSERT_FALSE(DebianJessie.IsRedhat());
   ASSERT_FALSE(DebianJessie.IsOpenSUSE());
   ASSERT_TRUE(DebianJessie.IsDebian());
   ASSERT_FALSE(DebianJessie.IsGentoo());
 
   llvm::vfs::InMemoryFileSystem DebianStretchSidFileSystem;
   DebianStretchSidFileSystem.addFile("/etc/debian_version", 0,
                                  llvm::MemoryBuffer::getMemBuffer("stretch/sid\n"));
   DebianStretchSidFileSystem.addFile("/etc/os-release", 0,
       llvm::MemoryBuffer::getMemBuffer("PRETTY_NAME=\"Debian GNU/Linux stretch/sid\"\n"
                                        "NAME=\"Debian GNU/Linux\"\n"
                                        "ID=debian\n"
                                        "HOME_URL=\"http://www.debian.org/\"\n"
                                        "SUPPORT_URL=\"http://www.debian.org/support\"\n"
                                        "BUG_REPORT_URL=\"https://bugs.debian.org/\"\n"));
 
-  Distro DebianStretchSid{DebianStretchSidFileSystem};
+  Distro DebianStretchSid{DebianStretchSidFileSystem, llvm::Triple("unknown-pc-linux")};
   ASSERT_EQ(Distro(Distro::DebianStretch), DebianStretchSid);
   ASSERT_FALSE(DebianStretchSid.IsUbuntu());
   ASSERT_FALSE(DebianStretchSid.IsRedhat());
   ASSERT_FALSE(DebianStretchSid.IsOpenSUSE());
   ASSERT_TRUE(DebianStretchSid.IsDebian());
   ASSERT_FALSE(DebianStretchSid.IsGentoo());
 }
 
 TEST(DistroTest, DetectExherbo) {
   llvm::vfs::InMemoryFileSystem ExherboFileSystem;
   ExherboFileSystem.addFile("/etc/exherbo-release", 0, // (ASCII art)
                                  llvm::MemoryBuffer::getMemBuffer(""));
   ExherboFileSystem.addFile("/etc/os-release", 0,
       llvm::MemoryBuffer::getMemBuffer("NAME=\"Exherbo\"\n"
                                        "PRETTY_NAME=\"Exherbo Linux\"\n"
                                        "ID=\"exherbo\"\n"
                                        "ANSI_COLOR=\"0;32\"\n"
                                        "HOME_URL=\"https://www.exherbo.org/\"\n"
                                        "SUPPORT_URL=\"irc://irc.freenode.net/#exherbo\"\n"
                                        "BUG_REPORT_URL=\"https://bugs.exherbo.org/\"\n"));
 
-  Distro Exherbo{ExherboFileSystem};
+  Distro Exherbo{ExherboFileSystem, llvm::Triple("unknown-pc-linux")};
   ASSERT_EQ(Distro(Distro::Exherbo), Exherbo);
   ASSERT_FALSE(Exherbo.IsUbuntu());
   ASSERT_FALSE(Exherbo.IsRedhat());
   ASSERT_FALSE(Exherbo.IsOpenSUSE());
   ASSERT_FALSE(Exherbo.IsDebian());
   ASSERT_FALSE(Exherbo.IsGentoo());
 }
 
 TEST(DistroTest, DetectArchLinux) {
   llvm::vfs::InMemoryFileSystem ArchLinuxFileSystem;
   ArchLinuxFileSystem.addFile("/etc/arch-release", 0, // (empty)
                                  llvm::MemoryBuffer::getMemBuffer(""));
   ArchLinuxFileSystem.addFile("/etc/os-release", 0,
       llvm::MemoryBuffer::getMemBuffer("NAME=\"Arch Linux\"\n"
                                        "ID=arch\n"
                                        "PRETTY_NAME=\"Arch Linux\"\n"
                                        "ANSI_COLOR=\"0;36\"\n"
                                        "HOME_URL=\"https://www.archlinux.org/\"\n"
                                        "SUPPORT_URL=\"https://bbs.archlinux.org/\"\n"
                                        "BUG_REPORT_URL=\"https://bugs.archlinux.org/\"\n"));
 
-  Distro ArchLinux{ArchLinuxFileSystem};
+  Distro ArchLinux{ArchLinuxFileSystem, llvm::Triple("unknown-pc-linux")};
   ASSERT_EQ(Distro(Distro::ArchLinux), ArchLinux);
   ASSERT_FALSE(ArchLinux.IsUbuntu());
   ASSERT_FALSE(ArchLinux.IsRedhat());
   ASSERT_FALSE(ArchLinux.IsOpenSUSE());
   ASSERT_FALSE(ArchLinux.IsDebian());
   ASSERT_FALSE(ArchLinux.IsGentoo());
 }
 
 TEST(DistroTest, DetectGentoo) {
   llvm::vfs::InMemoryFileSystem GentooFileSystem;
   GentooFileSystem.addFile(
       "/etc/gentoo-release", 0,
       llvm::MemoryBuffer::getMemBuffer("Gentoo Base System release 2.6"));
   GentooFileSystem.addFile(
       "/etc/os-release", 0,
       llvm::MemoryBuffer::getMemBuffer(
           "NAME=Gentoo\n"
           "ID=gentoo\n"
           "PRETTY_NAME=\"Gentoo/Linux\"\n"
           "ANSI_COLOR=\"1;32\"\n"
           "HOME_URL=\"https://www.gentoo.org/\"\n"
           "SUPPORT_URL=\"https://www.gentoo.org/support/\"\n"
           "BUG_REPORT_URL=\"https://bugs.gentoo.org/\"\n"));
 
-  Distro Gentoo{GentooFileSystem};
+  Distro Gentoo{GentooFileSystem, llvm::Triple("unknown-pc-linux")};
   ASSERT_EQ(Distro(Distro::Gentoo), Gentoo);
   ASSERT_FALSE(Gentoo.IsUbuntu());
   ASSERT_FALSE(Gentoo.IsRedhat());
   ASSERT_FALSE(Gentoo.IsOpenSUSE());
   ASSERT_FALSE(Gentoo.IsDebian());
   ASSERT_TRUE(Gentoo.IsGentoo());
 }
 
+TEST(DistroTest, DetectWindowsAndCrossCompile) {
+
+  class CountingFileSystem : public llvm::vfs::ProxyFileSystem {
+  public:
+    CountingFileSystem() : ProxyFileSystem(llvm::vfs::getRealFileSystem()) {}
+
+    llvm::ErrorOr<llvm::vfs::Status> status(const llvm::Twine &Path) override {
+      ++Count;
+      return llvm::vfs::ProxyFileSystem::status(Path);
+    }
+
+    llvm::ErrorOr<std::unique_ptr<llvm::vfs::File>>
+    openFileForRead(const llvm::Twine &Path) override {
+      ++Count;
+      return llvm::vfs::ProxyFileSystem::openFileForRead(Path);
+    }
+
+    unsigned Count{};
+  };
+
+  llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> RFS =
+      llvm::vfs::getRealFileSystem();
+  llvm::Triple Host(llvm::sys::getProcessTriple());
+
+  CountingFileSystem CFileSystem;
+  Distro LinuxDistro{CFileSystem, llvm::Triple("unknown-pc-linux")};
+  if (Host.isOSWindows()) {
+    ASSERT_EQ(Distro(Distro::UnknownDistro), LinuxDistro);
+    ASSERT_GT(CFileSystem.Count, 0U);
+  }
+
+  Distro WinDistro{CFileSystem, llvm::Triple("unknown-pc-windows")};
+  ASSERT_EQ(Distro(Distro::UnknownDistro), WinDistro);
+  ASSERT_GT(CFileSystem.Count, 0U);
+
+  // When running on Windows along with a real file system, ensure that no
+  // distro is returned if targeting Linux
+  if (Host.isOSWindows()) {
+    Distro LinuxRealDistro{*RFS, llvm::Triple("unknown-pc-linux")};
+    ASSERT_EQ(Distro(Distro::UnknownDistro), LinuxRealDistro);
+  }
+  // When running on Linux, check if the distro is the same as the host when
+  // targeting Linux
+  if (Host.isOSLinux()) {
+    Distro HostDistro{*RFS, Host};
+    Distro LinuxRealDistro{*RFS, llvm::Triple("unknown-pc-linux")};
+    ASSERT_EQ(HostDistro, LinuxRealDistro);
+  }
+
+  Distro WinRealDistro{*RFS, llvm::Triple("unknown-pc-windows")};
+  ASSERT_EQ(Distro(Distro::UnknownDistro), WinRealDistro);
+}
+
 } // end anonymous namespace