[Driver][RISCV] Find baremetal multilibs using YAML for GNU toolchain

[Joe]

Summary

This patch allows usage of multilib.yaml when using a riscv gnu toolchain

This could certainly land as three separate patches, but I wanted to put this up as one to gather feedback to make sure the direction makes sense.

These are the main discussion points I want to bring to attention:

1. For the RISCVMultilibFlags, the mabi flag is used in combination with all the march extension features (e.g +m). Notably, this doesn't align with the current arm/aarch64 multilib flags, which all flags corresponding to the command line flag. E.G -march=. Does this violate a particular design decision, or can any target decide on whatever multilib flags they want?

2. The location of multilib.yaml for a gnu toolchain is in the lib directory of the sysroot. E.G riscv64-unknown-elf/lib/multilib.yaml. This differs from the baremetal location of "lib/clang-runtimes".

3. Does it make more sense to implement finding multilibs using yaml for riscv in the baremetal toolchain first? I was planning on doing it after.

Theoretically, I think this matching of multilibs could be done without the need for multilib.yaml, but it is indeed much easier considering the logic is already there.

[michaelplatings]

Hi Joe, it's nice to see multilib.yaml getting some adoption :)

For the RISCVMultilibFlags, the mabi flag is used in combination with all the march extension features (e.g +m). Notably, this doesn't align with the current arm/aarch64 multilib flags, which all flags corresponding to the command line flag. E.G -march=. Does this violate a particular design decision, or can any target decide on whatever multilib flags they want?

Multilib flags must be valid command line options. So as +a is not a valid command line option, it should not be used as a multilib flag.

That said, I'm very aware that it would be desirable to specify attributes independently of command line options, so I think there's room for the design to grow.

The location of multilib.yaml for a gnu toolchain is in the lib directory of the sysroot. E.G riscv64-unknown-elf/lib/multilib.yaml. This differs from the baremetal location of "lib/clang-runtimes".

The multilib.yaml design is agnostic to such decisions. If you can guarantee that all libraries will always use the exact same header files then it could make sense to have multilib apply only to libs. For the BareMetal toolchain I wanted to keep the flexibility of allowing different headers to be associated with each library.

Does it make more sense to implement finding multilibs using yaml for riscv in the baremetal toolchain first? I was planning on doing it after.

No strong opinion from me on this one. Doing BareMetal first might lend itself to a more consistent end result.

[Joe]

Theoretically, I think this matching of multilibs could be done without the need for multilib.yaml, but it is indeed much easier considering the logic is already there.

Actually, I retract this statement. There would be no way of knowing what the default library is without something telling you, i.e. a yaml file.

@michaelplatings thank you for the speedy comment!

Multilib flags must be valid command line options. So as +a is not a valid command line option, it should not be used as a multilib flag.

That said, I'm very aware that it would be desirable to specify attributes independently of command line options, so I think there's room for the design to grow.

Matching on extension is the most important thing for riscv. The only other way to do it under the current vision of multilib flags, as far as I'm aware, are some nasty and repetitive regexes. Do you think we could allow the design to grow to allow attributes prefixed by + in addition to flags?

[Joe]

Add default ABI to multilib flags if none supplied

[michaelplatings]

some nasty and repetitive regexes

Yes, it's the same for Arm architecture extensions. Petr & I went back and forth on this for a long time. See discussion here to understand Petr's concerns: https://discourse.llvm.org/t/rfc-multilib/67494/23

clang/include/clang/Driver/ToolChain.h

 //===- ToolChain.h - Collections of tools for one platform ------*- 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_TOOLCHAIN_H
 #define LLVM_CLANG_DRIVER_TOOLCHAIN_H
 
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/Sanitizers.h"
 #include "clang/Driver/Action.h"
-#include "clang/Driver/Multilib.h"
+#include "clang/Driver/MultilibBuilder.h"
 #include "clang/Driver/Types.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FloatingPointMode.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Frontend/Debug/Options.h"
 #include "llvm/MC/MCTargetOptions.h"

 
 namespace driver {
 
 class Driver;
 class InputInfo;
 class SanitizerArgs;
 class Tool;
 class XRayArgs;
+struct DetectedMultilibs;
 
 /// Helper structure used to pass information extracted from clang executable
 /// name such as `i686-linux-android-g++`.
 struct ParsedClangName {
   /// Target part of the executable name, as `i686-linux-android`.
   std::string TargetPrefix;
 
   /// Driver mode part of the executable name, as `g++`.
public:
   virtual ~ToolChain();
 
   // Accessors
 
   const Driver &getDriver() const { return D; }
   llvm::vfs::FileSystem &getVFS() const;
   const llvm::Triple &getTriple() const { return Triple; }
 
+  static constexpr llvm::StringLiteral MultilibFilename = "multilib.yaml";
+
   /// Get the toolchain's aux triple, if it has one.
   ///
   /// Exactly what the aux triple represents depends on the toolchain, but for
   /// example when compiling CUDA code for the GPU, the triple might be NVPTX,
   /// while the aux triple is the host (CPU) toolchain, e.g. x86-linux-gnu.
   virtual const llvm::Triple *getAuxTriple() const { return nullptr; }
 
   /// Some toolchains need to modify the file name, for example to replace the
if (TT.getVendor() == llvm::Triple::UnknownVendor ||
         return llvm::Triple("nvptx-nvidia-cuda");
       if (TT.getArch() == llvm::Triple::nvptx64)
         return llvm::Triple("nvptx64-nvidia-cuda");
       if (TT.getArch() == llvm::Triple::amdgcn)
         return llvm::Triple("amdgcn-amd-amdhsa");
     }
     return TT;
   }
+
+  void findMultilibsFromYAML(StringRef MultilibPath,
+                             const llvm::opt::ArgList &Args,
+                             DetectedMultilibs &Result) const;
+
 };
 
 /// Set a ToolChain's effective triple. Reset it when the registration object
 /// is destroyed.
 class RegisterEffectiveTriple {
   const ToolChain &TC;
 
 public:

clang/lib/Driver/ToolChain.cpp

 //===- ToolChain.cpp - Collections of tools for one platform --------------===//
 //
 // 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/ToolChain.h"
 #include "ToolChains/Arch/AArch64.h"
 #include "ToolChains/Arch/ARM.h"
+#include "ToolChains/Arch/RISCV.h"
 #include "ToolChains/Clang.h"
 #include "ToolChains/CommonArgs.h"
 #include "ToolChains/Flang.h"
+#include "ToolChains/Gnu.h"
 #include "ToolChains/InterfaceStubs.h"
 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Basic/Sanitizers.h"
 #include "clang/Config/config.h"
 #include "clang/Driver/Action.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/InputInfo.h"

 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/RISCVISAInfo.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/TargetParser/AArch64TargetParser.h"
 #include "llvm/TargetParser/TargetParser.h"
 #include "llvm/TargetParser/Triple.h"
 #include <cassert>
 #include <cstddef>
 #include <cstring>
+#include <sstream>
 #include <string>
 
 using namespace clang;
 using namespace driver;
 using namespace tools;
 using namespace llvm;
 using namespace llvm::opt;
 
#include "llvm/TargetParser/ARMTargetParser.def"
   case arm::FloatABI::Hard:
     Result.push_back("-mfloat-abi=hard");
     break;
   case arm::FloatABI::Invalid:
     llvm_unreachable("Invalid float ABI");
   }
 }
 
+static void getRISCVMultilibFlags(const Driver &D, const llvm::Triple &Triple,
+                                  const llvm::opt::ArgList &Args,
+                                  Multilib::flags_list &Result) {
+  std::vector<StringRef> Features;
+  riscv::getRISCVTargetFeatures(D, Triple, Args, Features);
+  const auto UnifiedFeatures = tools::unifyTargetFeatures(Features);
+  llvm::DenseSet<StringRef> FeatureSet(UnifiedFeatures.begin(),
+                                       UnifiedFeatures.end());
+  // Add all Extenstion features
+  for (StringRef Feature : Features) {
+    std::string FeatureStr = Feature.str();
+    if (FeatureStr.front() != '+')
+      continue;
+    // get rid of +/- on Feature
+    if (RISCVISAInfo::isSupportedExtensionFeature(FeatureStr.substr(1)))
+      Result.push_back(FeatureStr);
+  }
+
+  if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
+    Result.push_back(std::string("-mabi=") + A->getValue());
+  } else {
+    std::vector<std::string> FeatureStrs;
+    for (StringRef Feature : Features)
+      FeatureStrs.push_back(Feature.str());
+    unsigned XLen = Triple.isRISCV32() ? 32 : 64;
+    if (auto ISAInfo = RISCVISAInfo::parseFeatures(XLen, FeatureStrs)) {
+      std::string ABI = ISAInfo.get()->computeDefaultABI().str();
+      Result.push_back(std::string("-mabi=") + ABI);
+    }
+  }
+}
+
 Multilib::flags_list
 ToolChain::getMultilibFlags(const llvm::opt::ArgList &Args) const {
   using namespace clang::driver::options;
 
   std::vector<std::string> Result;
   const llvm::Triple Triple(ComputeEffectiveClangTriple(Args));
-  Result.push_back("--target=" + Triple.str());
 
   switch (Triple.getArch()) {
   case llvm::Triple::aarch64:
   case llvm::Triple::aarch64_32:
   case llvm::Triple::aarch64_be:
+    Result.push_back("--target=" + Triple.str());
     getAArch64MultilibFlags(D, Triple, Args, Result);
     break;
   case llvm::Triple::arm:
   case llvm::Triple::armeb:
   case llvm::Triple::thumb:
   case llvm::Triple::thumbeb:
+    Result.push_back("--target=" + Triple.str());
     getARMMultilibFlags(D, Triple, Args, Result);
     break;
+  case llvm::Triple::riscv32:
+  case llvm::Triple::riscv64:
+    getRISCVMultilibFlags(D, Triple, Args, Result);
   default:
     break;
   }
 
   // Sort and remove duplicates.
   std::sort(Result.begin(), Result.end());
   Result.erase(std::unique(Result.begin(), Result.end()), Result.end());
   return Result;
llvm::opt::DerivedArgList *ToolChain::TranslateXarchArgs(
   }
 
   if (Modified)
     return DAL;
 
   delete DAL;
   return nullptr;
 }
+
+void ToolChain::findMultilibsFromYAML(StringRef MultilibPath,
+    const llvm::opt::ArgList &Args, DetectedMultilibs &Result) const {
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MB =
+      getDriver().getVFS().getBufferForFile(MultilibPath);
+  if (!MB)
+    return;
+  Multilib::flags_list Flags = getMultilibFlags(Args);
+  llvm::ErrorOr<MultilibSet> ErrorOrMultilibSet =
+      MultilibSet::parseYaml(*MB.get());
+  if (ErrorOrMultilibSet.getError())
+    return;
+  Result.Multilibs = ErrorOrMultilibSet.get();
+  if (Result.Multilibs.select(Flags, Result.SelectedMultilibs))
+    return;
+  getDriver().Diag(clang::diag::warn_drv_missing_multilib) << llvm::join(Flags, " ");
+  std::stringstream ss;
+  for (const Multilib &Multilib : Result.Multilibs)
+    ss << "\n" << llvm::join(Multilib.flags(), " ");
+  getDriver().Diag(clang::diag::note_drv_available_multilibs) << ss.str();
+}

clang/lib/Driver/ToolChains/BareMetal.cpp

if (Triple.getVendor() != llvm::Triple::UnknownVendor)
     return false;
 
   if (Triple.getOS() != llvm::Triple::UnknownOS)
     return false;
 
   return Triple.getEnvironmentName() == "elf";
 }
 
-static void findMultilibsFromYAML(const ToolChain &TC, const Driver &D,
-                                  StringRef MultilibPath, const ArgList &Args,
-                                  DetectedMultilibs &Result) {
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MB =
-      D.getVFS().getBufferForFile(MultilibPath);
-  if (!MB)
-    return;
-  Multilib::flags_list Flags = TC.getMultilibFlags(Args);
-  llvm::ErrorOr<MultilibSet> ErrorOrMultilibSet =
-      MultilibSet::parseYaml(*MB.get());
-  if (ErrorOrMultilibSet.getError())
-    return;
-  Result.Multilibs = ErrorOrMultilibSet.get();
-  if (Result.Multilibs.select(Flags, Result.SelectedMultilibs))
-    return;
-  D.Diag(clang::diag::warn_drv_missing_multilib) << llvm::join(Flags, " ");
-  std::stringstream ss;
-  for (const Multilib &Multilib : Result.Multilibs)
-    ss << "\n" << llvm::join(Multilib.flags(), " ");
-  D.Diag(clang::diag::note_drv_available_multilibs) << ss.str();
-}
-
-static constexpr llvm::StringLiteral MultilibFilename = "multilib.yaml";
-
 // Get the sysroot, before multilib takes effect.
 static std::string computeBaseSysRoot(const Driver &D,
                                       const llvm::Triple &Triple) {
   if (!D.SysRoot.empty())
     return D.SysRoot;
 
   SmallString<128> SysRootDir(D.Dir);
   llvm::sys::path::append(SysRootDir, "..", "lib", "clang-runtimes");
 
   SmallString<128> MultilibPath(SysRootDir);
-  llvm::sys::path::append(MultilibPath, MultilibFilename);
+  llvm::sys::path::append(MultilibPath, ToolChain::MultilibFilename);
 
   // New behaviour: if multilib.yaml is found then use clang-runtimes as the
   // sysroot.
   if (D.getVFS().exists(MultilibPath))
     return std::string(SysRootDir);
 
   // Otherwise fall back to the old behaviour of appending the target triple.
   llvm::sys::path::append(SysRootDir, D.getTargetTriple());
   return std::string(SysRootDir);
 }
 
 void BareMetal::findMultilibs(const Driver &D, const llvm::Triple &Triple,
                               const ArgList &Args) {
   DetectedMultilibs Result;
   if (isRISCVBareMetal(Triple)) {
     if (findRISCVMultilibs(D, Triple, Args, Result)) {
       SelectedMultilibs = Result.SelectedMultilibs;
       Multilibs = Result.Multilibs;
     }
   } else {
     llvm::SmallString<128> MultilibPath(computeBaseSysRoot(D, Triple));
-    llvm::sys::path::append(MultilibPath, MultilibFilename);
-    findMultilibsFromYAML(*this, D, MultilibPath, Args, Result);
+    llvm::sys::path::append(MultilibPath, ToolChain::MultilibFilename);
+    findMultilibsFromYAML(MultilibPath, Args, Result);
     SelectedMultilibs = Result.SelectedMultilibs;
     Multilibs = Result.Multilibs;
   }
 }
 
 bool BareMetal::handlesTarget(const llvm::Triple &Triple) {
   return isARMBareMetal(Triple) || isAArch64BareMetal(Triple) ||
          isRISCVBareMetal(Triple);

clang/lib/Driver/ToolChains/Gnu.h

public:
   ///
   /// This class tries to find a GCC installation on the system, and report
   /// information about it. It starts from the host information provided to the
   /// Driver, and has logic for fuzzing that where appropriate.
   class GCCInstallationDetector {
     bool IsValid;
     llvm::Triple GCCTriple;
     const Driver &D;
+    const ToolChain &TC;
 
     // FIXME: These might be better as path objects.
     std::string GCCInstallPath;
     std::string GCCParentLibPath;
 
     /// The primary multilib appropriate for the given flags.
     Multilib SelectedMultilib;
     /// On Biarch systems, this corresponds to the default multilib when
     /// targeting the non-default multilib. Otherwise, it is empty.
     std::optional<Multilib> BiarchSibling;
 
     GCCVersion Version;
 
     // We retain the list of install paths that were considered and rejected in
     // order to print out detailed information in verbose mode.
     std::set<std::string> CandidateGCCInstallPaths;
 
     /// The set of multilibs that the detected installation supports.
     MultilibSet Multilibs;
 
     // Gentoo-specific toolchain configurations are stored here.
     const std::string GentooConfigDir = "/etc/env.d/gcc";
 
   public:
-    explicit GCCInstallationDetector(const Driver &D) : IsValid(false), D(D) {}
+    explicit GCCInstallationDetector(const Driver &D, const
+        ToolChain &TC) : IsValid(false), D(D), TC(TC) {}
     void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args,
               ArrayRef<std::string> ExtraTripleAliases = std::nullopt);
 
     /// Check whether we detected a valid GCC install.
     bool isValid() const { return IsValid; }
 
     /// Get the GCC triple for the detected install.
     const llvm::Triple &getTriple() const { return GCCTriple; }

clang/lib/Driver/ToolChains/Gnu.cpp

static void findCSKYMultilibs(const Driver &D, const llvm::Triple &TargetTriple,
 
   if (CSKYMultilibs.select(Flags, Result.SelectedMultilibs))
     Result.Multilibs = CSKYMultilibs;
 }
 
 static void findRISCVBareMetalMultilibs(const Driver &D,
                                         const llvm::Triple &TargetTriple,
                                         StringRef Path, const ArgList &Args,
-                                        DetectedMultilibs &Result) {
+                                        DetectedMultilibs &Result,
+                                        const ToolChain &TC) {
+  auto FilePathsCallback = [](const Multilib &M) {
+    return std::vector<std::string>(
+        {M.gccSuffix(), "/../../../../riscv64-unknown-elf/lib" + M.gccSuffix(),
+         "/../../../../riscv32-unknown-elf/lib" + M.gccSuffix()});
+  };
+
+  // Find multilib.yaml and use that if it exists
+  // The name of the sysroot can be either riscv32 or riscv64, so check both.
+  std::optional<SmallString<128>> ExistingMultilibYamlPath = std::nullopt;
+  SmallString<128> Toplevel(Path);
+  llvm::sys::path::append(Toplevel, "..", "..", "..", "..");
+  SmallString<128> MultilibYamlPath32(Toplevel);
+  SmallString<128> MultilibYamlPath64(Toplevel);
+
+  llvm::sys::path::append(MultilibYamlPath64, "riscv64-unknown-elf", "lib",
+                          ToolChain::MultilibFilename);
+  llvm::sys::path::append(MultilibYamlPath32, "riscv32-unknown-elf", "lib",
+                          ToolChain::MultilibFilename);
+  if (D.getVFS().exists(MultilibYamlPath64))
+    ExistingMultilibYamlPath = MultilibYamlPath64;
+  else if (D.getVFS().exists(MultilibYamlPath32))
+    ExistingMultilibYamlPath = MultilibYamlPath32;
+
+  if (ExistingMultilibYamlPath) {
+    TC.findMultilibsFromYAML(ExistingMultilibYamlPath.value(), Args, Result);
+    Result.Multilibs.setFilePathsCallback(FilePathsCallback);
+    return;
+  }
+
   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
   struct RiscvMultilib {
     StringRef march;
     StringRef mabi;
   };
   // currently only support the set of multilibs like riscv-gnu-toolchain does.
   // TODO: support MULTILIB_REUSE
   constexpr RiscvMultilib RISCVMultilibSet[] = {
       {"rv32i", "ilp32"},     {"rv32im", "ilp32"},     {"rv32iac", "ilp32"},
       {"rv32imac", "ilp32"},  {"rv32imafc", "ilp32f"}, {"rv64imac", "lp64"},
       {"rv64imafdc", "lp64d"}};
 
   std::vector<MultilibBuilder> Ms;
   for (auto Element : RISCVMultilibSet) {
     // multilib path rule is ${march}/${mabi}
     Ms.emplace_back(
         MultilibBuilder(
             (Twine(Element.march) + "/" + Twine(Element.mabi)).str())
             .flag(Twine("-march=", Element.march).str())
             .flag(Twine("-mabi=", Element.mabi).str()));
   }
-  MultilibSet RISCVMultilibs =
-      MultilibSetBuilder()
+  MultilibSet RISCVMultilibs = MultilibSetBuilder()
                                    .Either(Ms)
                                    .makeMultilibSet()
                                    .FilterOut(NonExistent)
-          .setFilePathsCallback([](const Multilib &M) {
-            return std::vector<std::string>(
-                {M.gccSuffix(),
-                 "/../../../../riscv64-unknown-elf/lib" + M.gccSuffix(),
-                 "/../../../../riscv32-unknown-elf/lib" + M.gccSuffix()});
-          });
+                                   .setFilePathsCallback(FilePathsCallback);
 
   Multilib::flags_list Flags;
   llvm::StringSet<> Added_ABIs;
   StringRef ABIName = tools::riscv::getRISCVABI(Args, TargetTriple);
   StringRef MArch = tools::riscv::getRISCVArch(Args, TargetTriple);
   for (auto Element : RISCVMultilibSet) {
     addMultilibFlag(MArch == Element.march,
                     Twine("-march=", Element.march).str().c_str(), Flags);
     if (!Added_ABIs.count(Element.mabi)) {
       Added_ABIs.insert(Element.mabi);
       addMultilibFlag(ABIName == Element.mabi,
                       Twine("-mabi=", Element.mabi).str().c_str(), Flags);
     }
   }
 
   if (RISCVMultilibs.select(Flags, Result.SelectedMultilibs))
     Result.Multilibs = RISCVMultilibs;
 }
 
 static void findRISCVMultilibs(const Driver &D,
                                const llvm::Triple &TargetTriple, StringRef Path,
-                               const ArgList &Args, DetectedMultilibs &Result) {
+                               const ArgList &Args, DetectedMultilibs &Result,
+                               const ToolChain &TC) {
   if (TargetTriple.getOS() == llvm::Triple::UnknownOS)
-    return findRISCVBareMetalMultilibs(D, TargetTriple, Path, Args, Result);
+    return findRISCVBareMetalMultilibs(D, TargetTriple, Path, Args, Result, TC);
 
   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
   MultilibBuilder Ilp32 =
       MultilibBuilder("lib32/ilp32").flag("-m32").flag("-mabi=ilp32");
   MultilibBuilder Ilp32f =
       MultilibBuilder("lib32/ilp32f").flag("-m32").flag("-mabi=ilp32f");
   MultilibBuilder Ilp32d =
       MultilibBuilder("lib32/ilp32d").flag("-m32").flag("-mabi=ilp32d");
if (isArmOrThumbArch(TargetArch) && TargetTriple.isAndroid()) {
     // It should also work without multilibs in a simplified toolchain.
     findAndroidArmMultilibs(D, TargetTriple, Path, Args, Detected);
   } else if (TargetTriple.isCSKY()) {
     findCSKYMultilibs(D, TargetTriple, Path, Args, Detected);
   } else if (TargetTriple.isMIPS()) {
     if (!findMIPSMultilibs(D, TargetTriple, Path, Args, Detected))
       return false;
   } else if (TargetTriple.isRISCV()) {
-    findRISCVMultilibs(D, TargetTriple, Path, Args, Detected);
+    findRISCVMultilibs(D, TargetTriple, Path, Args, Detected, TC);
   } else if (isMSP430(TargetArch)) {
     findMSP430Multilibs(D, TargetTriple, Path, Args, Detected);
   } else if (TargetArch == llvm::Triple::avr) {
     // AVR has no multilibs.
   } else if (!findBiarchMultilibs(D, TargetTriple, Path, Args,
                                   NeedsBiarchSuffix, Detected)) {
     return false;
   }
if (File) {
     }
   }
 
   return false;
 }
 
 Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple &Triple,
                          const ArgList &Args)
-    : ToolChain(D, Triple, Args), GCCInstallation(D),
+    : ToolChain(D, Triple, Args), GCCInstallation(D, *this),
       CudaInstallation(D, Triple, Args), RocmInstallation(D, Triple, Args) {
   getProgramPaths().push_back(getDriver().getInstalledDir());
   if (getDriver().getInstalledDir() != getDriver().Dir)
     getProgramPaths().push_back(getDriver().Dir);
 }
 
 Generic_GCC::~Generic_GCC() {}
 

clang/test/Driver/Inputs/multilib_riscv_elf_sdk_yaml/riscv64-unknown-elf/bin/ld

+#!/bin/true

clang/test/Driver/Inputs/multilib_riscv_elf_sdk_yaml/riscv64-unknown-elf/lib/multilib.yaml

+---
+# How does clang use this file?
+# 1. If the ToolChain class for the architecture supports this form of
+#    multilib it then it loads the file if present in sysroot.
+# 2. Generate flags from the user provided arguments.
+#    (Use `clang -print-multi-flags-experimental` to see which flags are
+#    generated).
+# 3. Compare the arguments against each regular expression and store
+#    associated flags if there's a match.
+# 4. Find the last library variant whose flags are a subset of the
+#    flags derived from the user provided arguments.
+# 5. Use the directory for the library variant as the sysroot.
+
+# Clang will emit an error if this number is greater than its current multilib
+# version or if its major version differs, but will accept lesser minor
+# versions.
+MultilibVersion: 1.0
+
+# A library is considered compatible if the are a subset of the flags derived
+# from the arguments provided by the user.
+# If multiple libraries are deemed compatible then the one that appears
+# last in the list wins.
+Variants:
+- Dir: rv32i/ilp32
+  Flags: [-mabi=ilp32]
+
+- Dir: rv32iac/ilp32
+  Flags: [-mabi=ilp32, +a, +c]
+
+- Dir: rv32im/ilp32
+  Flags: [-mabi=ilp32, +m]
+
+- Dir: rv32imac/ilp32
+  Flags: [-mabi=ilp32, +m, +a, +c]
+
+- Dir: rv32imafc/ilp32f
+  Flags: [-mabi=ilp32f, +m, +a, +f, +c]
+
+- Dir: rv64imac/lp64
+  Flags: [-mabi=lp64, +m, +a, +c]
+
+# GCC sysroots will have a default march/mabi sitting at the top level. Assume
+# this is rv64imafdc/lp64d for this test.
+- Dir: .
+  Flags: [-mabi=lp64d, +m, +a, +d, +c]
+...

clang/test/Driver/riscv-toolchain-multilib-yaml.c

+// UNSUPPORTED: system-windows
+// In this test, multilib resolution is resolved using a multilib.yaml
+// definition, in which multilibs are picked in accordance to matching abi /
+// marchs.
+
+// RUN: env "PATH=" %clang -### %s -fuse-ld=ld \
+// RUN:   --target=riscv32-unknown-elf --rtlib=platform --sysroot= \
+// RUN:   -march=rv32iac -mabi=ilp32\
+// RUN:   --gcc-toolchain=%S/Inputs/multilib_riscv_elf_sdk_yaml 2>&1 \
+// RUN:   | FileCheck -check-prefix=C-RV32IAC-BAREMETAL-MULTI-ILP32 %s
+
+// C-RV32IAC-BAREMETAL-MULTI-ILP32: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0/../../..{{/|\\\\}}..{{/|\\\\}}riscv64-unknown-elf/lib/rv32iac/ilp32{{/|\\\\}}crt0.o"
+// C-RV32IAC-BAREMETAL-MULTI-ILP32: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0/rv32iac/ilp32{{/|\\\\}}crtbegin.o"
+// C-RV32IAC-BAREMETAL-MULTI-ILP32: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0/rv32iac/ilp32{{/|\\\\}}crtend.o"
+
+// RUN: env "PATH=" %clang -### %s -fuse-ld=ld \
+// RUN:   --target=riscv32-unknown-elf --rtlib=platform --sysroot= \
+// RUN:   -march=rv32imafc -mabi=ilp32f\
+// RUN:   --gcc-toolchain=%S/Inputs/multilib_riscv_elf_sdk_yaml 2>&1 \
+// RUN:   | FileCheck -check-prefix=C-RV32IMAFC-BAREMETAL-MULTI-ILP32F %s
+
+// C-RV32IMAFC-BAREMETAL-MULTI-ILP32F: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0/../../..{{/|\\\\}}..{{/|\\\\}}riscv64-unknown-elf/lib/rv32imafc/ilp32f{{/|\\\\}}crt0.o"
+// C-RV32IMAFC-BAREMETAL-MULTI-ILP32F: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0/rv32imafc/ilp32f{{/|\\\\}}crtbegin.o"
+// C-RV32IMAFC-BAREMETAL-MULTI-ILP32F: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0/rv32imafc/ilp32f{{/|\\\\}}crtend.o"
+
+// Check the addition of extensions for which we don't have an exact match of multilib
+// RUN: env "PATH=" %clang -### %s -fuse-ld=ld \
+// RUN:   --target=riscv32-unknown-elf --rtlib=platform --sysroot= \
+// RUN:   -march=rv32imafc_zba -mabi=ilp32f\
+// RUN:   --gcc-toolchain=%S/Inputs/multilib_riscv_elf_sdk_yaml 2>&1 \
+// RUN:   | FileCheck -check-prefix=C-RV32IMAFC-ZBA-BAREMETAL-MULTI-ILP32F %s
+
+// C-RV32IMAFC-ZBA-BAREMETAL-MULTI-ILP32F: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0/../../..{{/|\\\\}}..{{/|\\\\}}riscv64-unknown-elf/lib/rv32imafc/ilp32f{{/|\\\\}}crt0.o"
+// C-RV32IMAFC-ZBA-BAREMETAL-MULTI-ILP32F: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0/rv32imafc/ilp32f{{/|\\\\}}crtbegin.o"
+// C-RV32IMAFC-ZBA-BAREMETAL-MULTI-ILP32F: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0/rv32imafc/ilp32f{{/|\\\\}}crtend.o"
+
+// RUN: env "PATH=" %clang -### %s -fuse-ld=ld \
+// RUN:   --target=riscv64-unknown-elf --rtlib=platform --sysroot= \
+// RUN:   -march=rv64imac_zba -mabi=lp64\
+// RUN:   --gcc-toolchain=%S/Inputs/multilib_riscv_elf_sdk_yaml 2>&1 \
+// RUN:   | FileCheck -check-prefix=C-RV64IMAC-ZBA-BAREMETAL-MULTI-LP64 %s
+
+// C-RV64IMAC-ZBA-BAREMETAL-MULTI-LP64: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0/../../..{{/|\\\\}}..{{/|\\\\}}riscv64-unknown-elf/lib/rv64imac/lp64{{/|\\\\}}crt0.o"
+// C-RV64IMAC-ZBA-BAREMETAL-MULTI-LP64: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0/rv64imac/lp64{{/|\\\\}}crtbegin.o"
+// C-RV64IMAC-ZBA-BAREMETAL-MULTI-LP64: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0/rv64imac/lp64{{/|\\\\}}crtend.o"
+
+// For this toolchain, rv64imafdc is considered the default toplevel multilib. Check this.
+// RUN: env "PATH=" %clang -### %s -fuse-ld=ld \
+// RUN:   --target=riscv64-unknown-elf --rtlib=platform --sysroot= \
+// RUN:   -march=rv64imafdc -mabi=lp64d\
+// RUN:   --gcc-toolchain=%S/Inputs/multilib_riscv_elf_sdk_yaml 2>&1 \
+// RUN:   | FileCheck -check-prefix=C-RV64IMAFDC-BAREMETAL-MULTI-LP64D %s
+
+// Check default ABI is added
+// RUN: env "PATH=" %clang -### %s -fuse-ld=ld \
+// RUN:   --target=riscv64-unknown-elf --rtlib=platform --sysroot= \
+// RUN:   -march=rv64imafdc \
+// RUN:   --gcc-toolchain=%S/Inputs/multilib_riscv_elf_sdk_yaml 2>&1 \
+// RUN:   | FileCheck -check-prefix=C-RV64IMAFDC-BAREMETAL-MULTI %s
+
+// C-RV64IMAFDC-BAREMETAL-MULTI: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0/../../..{{/|\\\\}}..{{/|\\\\}}riscv64-unknown-elf/lib{{/|\\\\}}crt0.o"
+// C-RV64IMAFDC-BAREMETAL-MULTI: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0{{/|\\\\}}crtbegin.o"
+// C-RV64IMAFDC-BAREMETAL-MULTI: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0{{/|\\\\}}crtend.o"
+
+// C-RV64IMAFDC-BAREMETAL-MULTI-LP64D: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0/../../..{{/|\\\\}}..{{/|\\\\}}riscv64-unknown-elf/lib{{/|\\\\}}crt0.o"
+// C-RV64IMAFDC-BAREMETAL-MULTI-LP64D: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0{{/|\\\\}}crtbegin.o"
+// C-RV64IMAFDC-BAREMETAL-MULTI-LP64D: "{{.*}}/Inputs/multilib_riscv_elf_sdk_yaml/lib/gcc/riscv64-unknown-elf/8.2.0{{/|\\\\}}crtend.o"
+
+// RUN: %clang -no-canonical-prefixes -print-multi-lib 2>&1 \
+// RUN:   --target=riscv64-unknown-elf --sysroot= \
+// RUN:   --gcc-toolchain=%S/Inputs/multilib_riscv_elf_sdk_yaml 2>&1 \
+// RUN:   | FileCheck --check-prefix=CHECK-PRINT-MULTI-LIB %s
+// CHECK-PRINT-MULTI-LIB: rv32i/ilp32;@mabi=ilp32
+// CHECK-PRINT-MULTI-LIB: rv32iac/ilp32;@mabi=ilp32
+// CHECK-PRINT-MULTI-LIB: rv32im/ilp32;@mabi=ilp32
+// CHECK-PRINT-MULTI-LIB: rv32imac/ilp32;@mabi=ilp32
+// CHECK-PRINT-MULTI-LIB: rv32imafc/ilp32f;@mabi=ilp32f
+// CHECK-PRINT-MULTI-LIB: rv64imac/lp64;@mabi=lp64
+// CHECK-PRINT-MULTI-LIB: .;@mabi=lp64d