Driver: Add preferred gcc triples for Red Hat operating systems

[tstellar]

Summary

The GCCInstallationDetector has a list of gcc triples to search
for when trying to find a valid gcc install on the system. When
all else is equal, clang selects the first triple that appears in
the list.

This causes a problem on Red Hat operating systems, since there
is a cross-compiler gcc package that uses the triple x86_64-linux-gnu
and since this is listed in the triple list before the system gcc
install (x86_64-redhat-linux), the cross-compiler is always selected
by clang.

To solve this, we make it possible for a distro to provide a list of
preferred triples that will be selected before any triples in the
generic triple list.

Another solution to this problem would be to reorder the generic triple
lists so that distro supplied triples come first. However, I don't
have confidence that I would be able to order the list so that it
is correct for every distro.

[MaskRay]

Haven't looked closely at this particular commit, but I think hard coding the detected triples is almost always a bad idea.

See https://reviews.llvm.org/D63497#2993662 for a longer comment.

The proper way is (1) making sure CMake LLVM_DEFAULT_TARGET_TRIPLE is correct at configure time (2) the user should specify the complete --target=.

Inferring random target triple from an incomplete --target=x86_64 really should not be supported.

[MaskRay]

I uploaded D109727 to clean up suse related *Triples elements in CollectLibDirsAndTriples.
The long-term plan is to remove the *Triples variables entirely.

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
 //
 //===----------------------------------------------------------------------===//
 
public:
   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, const llvm::Triple &TargetOrHost);
 
+  llvm::ArrayRef<std::string> getDefaultGCCTriples(llvm::Triple::ArchType Arch);
+
   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
 //
 //===----------------------------------------------------------------------===//
 
static Distro::DistroType GetDistro(llvm::vfs::FileSystem &VFS,
   }
   // This is mostly for passing tests which uses llvm::vfs::InMemoryFileSystem,
   // which is not "real".
   return DetectDistro(VFS);
 }
 
 Distro::Distro(llvm::vfs::FileSystem &VFS, const llvm::Triple &TargetOrHost)
     : DistroVal(GetDistro(VFS, TargetOrHost)) {}
+
+/// @return An array of triples that should be used first when searching for
+/// a candidate gcc install on the system.
+llvm::ArrayRef<std::string> Distro::getDefaultGCCTriples(llvm::Triple::ArchType Arch) {
+  if (!IsRedhat())
+    return None;
+
+  static const std::array<std::string, 1> RedHatAArch64Triples = {{
+    "aarch64-redhat-linux"
+  }};
+
+  static const std::array<std::string, 1> RedHatArmTriples = {{
+    "armv7hl-redhat-linux-gnueabi"
+  }};
+
+  static const std::array<std::string, 1> RedHatPPC64LETriples = {{
+    "ppc64le-redhat-linux"
+  }};
+
+  static const std::array<std::string, 1> RedHatSystemZTriples = {{
+    "s390x-redhat-linux"
+  }};
+
+  static const std::array<std::string, 1> RedHatX86Triples = {{
+    "i686-redhat-linux"
+  }};
+
+  static const std::array<std::string, 1> RedHatX86_64Triples = {{
+    "x86_64-redhat-linux"
+  }};
+
+  switch (Arch) {
+  default:
+    break;
+  case llvm::Triple::aarch64:
+    return RedHatAArch64Triples;
+  case llvm::Triple::arm:
+    return RedHatArmTriples;
+  case llvm::Triple::ppc64le:
+    return  RedHatPPC64LETriples;
+  case llvm::Triple::systemz:
+    return RedHatSystemZTriples;
+  case llvm::Triple::x86:
+    return RedHatX86Triples;
+  case llvm::Triple::x86_64:
+    return RedHatX86_64Triples;
+  }
+
+  return None;
+}

clang/lib/Driver/ToolChains/Linux.cpp

 //===--- Linux.h - Linux ToolChain Implementations --------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {
   if (Triple.getArch() == llvm::Triple::riscv32)
     return "lib32";
 
   return Triple.isArch32Bit() ? "lib" : "lib64";
 }
 
 Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
     : Generic_ELF(D, Triple, Args) {
-  GCCInstallation.init(Triple, Args);
+
+  Distro Distro(D.getVFS(), Triple);
+  GCCInstallation.init(Triple, Args, Distro.getDefaultGCCTriples(Triple.getArch()));
   Multilibs = GCCInstallation.getMultilibs();
   SelectedMultilib = GCCInstallation.getMultilib();
   llvm::Triple::ArchType Arch = Triple.getArch();
   std::string SysRoot = computeSysRoot();
   ToolChain::path_list &PPaths = getProgramPaths();
 
   Generic_GCC::PushPPaths(PPaths);
 
-  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()) {