[Driver] Enable selecting multiple multilibs

[michaelplatings]

Summary

This will enable layering multilibs on top of each other.
For example a multilib containing only a no-exceptions libc++ could be
layered on top of a multilib containing C libs. This avoids the need
to duplicate the C library for every libc++ variant.

This change doesn't expose the functionality externally, it only opens
the functionality up to be potentially used by ToolChain classes.

[michaelplatings]

Rebase and change llvm::SmallVector<Multilib, 1> to simply llvm::SmallVector<Multilib>

[michaelplatings]

Rebase

[michaelplatings]

Rebase

[michaelplatings]

Rebase

[michaelplatings]

Rebase

[peter.smith]

A couple of small suggestions but otherwise looks good to me.

clang/lib/Driver/ToolChains/BareMetal.cpp

226

Nit: the braces can be omitted here. No strong opinion as it may be better to keep consistency with the rest of the file rather than LLVM as a whole.

https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

clang/lib/Driver/ToolChains/Fuchsia.cpp

320

SelectedMultilibs.end() - 1 makes me a little nervous. This will work for the current container type (I think the standard requires it for vector and I don't think SmallVector would deviate from it. However in the unlikely event that the container changes and this isn't valid then this could break.

Perhaps use std::advance(SelectedMultilibs.end(), -1) which is more likely to break at compile time if this occurs.

Alternatively if this is just erasing all but the last element, maybe extract it, clear the container and reinsert.

[michaelplatings]

Rebase

[michaelplatings]

Rebase and apply changes requested by @peter.smith

[michaelplatings]

flags -> tags

[peter.smith]

I've set approved from the Arm side. Please leave some time for people in the US time zone to leave any final comments or ask for extensions.

[michaelplatings]

Rebase

[michaelplatings]

tags->flags

[michaelplatings]

Rebase

[michaelplatings]

Rebase

[michaelplatings]

Rebase

[michaelplatings]

Rebase

[michaelplatings]

Rebase

[phosek]

LGTM

[michaelplatings]

Rebase

clang/include/clang/Driver/Multilib.h

public:
   MultilibSet &FilterOut(FilterCallback F);
 
   /// Add a completed Multilib to the set
   void push_back(const Multilib &M);
 
   const_iterator begin() const { return Multilibs.begin(); }
   const_iterator end() const { return Multilibs.end(); }
 
-  /// Select compatible variants
-  multilib_list select(const Multilib::flags_list &Flags) const;
-
-  /// Pick the best multilib in the set, \returns false if none are compatible
-  bool select(const Multilib::flags_list &Flags, Multilib &M) const;
+  /// Select compatible variants, \returns false if none are compatible
+  bool select(const Multilib::flags_list &Flags,
+              llvm::SmallVector<Multilib> &) const;
 
   unsigned size() const { return Multilibs.size(); }
 
   /// Get the given flags plus flags found by matching them against the
   /// FlagMatchers and choosing the Flags of each accordingly. The select method
   /// calls this method so in most cases it's not necessary to call it directly.
   llvm::StringSet<> expandFlags(const Multilib::flags_list &) const;
 

clang/include/clang/Driver/ToolChain.h

private:
   }
 
   mutable std::optional<CXXStdlibType> cxxStdlibType;
   mutable std::optional<RuntimeLibType> runtimeLibType;
   mutable std::optional<UnwindLibType> unwindLibType;
 
 protected:
   MultilibSet Multilibs;
-  Multilib SelectedMultilib;
+  llvm::SmallVector<Multilib> SelectedMultilibs;
 
   ToolChain(const Driver &D, const llvm::Triple &T,
             const llvm::opt::ArgList &Args);
 
   /// Executes the given \p Executable and returns the stdout.
   llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
   executeToolChainProgram(StringRef Executable) const;
 
public:
   path_list &getFilePaths() { return FilePaths; }
   const path_list &getFilePaths() const { return FilePaths; }
 
   path_list &getProgramPaths() { return ProgramPaths; }
   const path_list &getProgramPaths() const { return ProgramPaths; }
 
   const MultilibSet &getMultilibs() const { return Multilibs; }
 
-  const Multilib &getMultilib() const { return SelectedMultilib; }
+  const llvm::SmallVector<Multilib> &getSelectedMultilibs() const {
+    return SelectedMultilibs;
+  }
 
   /// Get flags suitable for multilib selection, based on the provided clang
   /// command line arguments. The command line arguments aren't suitable to be
   /// used directly for multilib selection because they are not normalized and
   /// normalization is a complex process. The result of this function is similar
   /// to clang command line arguments except that the list of arguments is
   /// incomplete. Only certain command line arguments are processed. If more
   /// command line arguments are needed for multilib selection then this

clang/lib/Driver/Driver.cpp

if (C.getArgs().hasArg(options::OPT_print_multi_flags)) {
     for (const auto &FlagEntry : ExpandedFlags)
       SortedFlags.insert(FlagEntry.getKey());
     for (auto Flag : SortedFlags)
       llvm::outs() << Flag << '\n';
     return false;
   }
 
   if (C.getArgs().hasArg(options::OPT_print_multi_directory)) {
-    const Multilib &Multilib = TC.getMultilib();
+    for (const Multilib &Multilib : TC.getSelectedMultilibs()) {
       if (Multilib.gccSuffix().empty())
         llvm::outs() << ".\n";
       else {
         StringRef Suffix(Multilib.gccSuffix());
         assert(Suffix.front() == '/');
         llvm::outs() << Suffix.substr(1) << "\n";
       }
+    }
     return false;
   }
 
   if (C.getArgs().hasArg(options::OPT_print_target_triple)) {
     llvm::outs() << TC.getTripleString() << "\n";
     return false;
   }
 

clang/lib/Driver/Multilib.cpp

 
 MultilibSet &MultilibSet::FilterOut(FilterCallback F) {
   llvm::erase_if(Multilibs, F);
   return *this;
 }
 
 void MultilibSet::push_back(const Multilib &M) { Multilibs.push_back(M); }
 
-MultilibSet::multilib_list
-MultilibSet::select(const Multilib::flags_list &Flags) const {
+bool MultilibSet::select(const Multilib::flags_list &Flags,
+                         llvm::SmallVector<Multilib> &Selected) const {
   llvm::StringSet<> FlagSet(expandFlags(Flags));
-  multilib_list Result;
-  llvm::copy_if(Multilibs, std::back_inserter(Result),
+  Selected.clear();
+  llvm::copy_if(Multilibs, std::back_inserter(Selected),
                 [&FlagSet](const Multilib &M) {
                   for (const std::string &F : M.flags())
                     if (!FlagSet.contains(F))
                       return false;
                   return true;
                 });
-  return Result;
-}
-
-bool MultilibSet::select(const Multilib::flags_list &Flags,
-                         Multilib &Selected) const {
-  multilib_list Result = select(Flags);
-  if (Result.empty())
-    return false;
-  Selected = Result.back();
-  return true;
+  return !Selected.empty();
 }
 
 llvm::StringSet<>
 MultilibSet::expandFlags(const Multilib::flags_list &InFlags) const {
   llvm::StringSet<> Result;
   for (const auto &F : InFlags)
     Result.insert(F);
   for (const FlagMatcher &M : FlagMatchers) {

clang/lib/Driver/ToolChain.cpp

default:
     return getOS();
   }
 }
 
 std::string ToolChain::getCompilerRTPath() const {
   SmallString<128> Path(getDriver().ResourceDir);
   if (isBareMetal()) {
     llvm::sys::path::append(Path, "lib", getOSLibName());
-    Path += SelectedMultilib.gccSuffix();
+    if (!SelectedMultilibs.empty()) {
+      Path += SelectedMultilibs.back().gccSuffix();
+    }
   } else if (Triple.isOSUnknown()) {
     llvm::sys::path::append(Path, "lib");
   } else {
     llvm::sys::path::append(Path, "lib", getOSLibName());
   }
   return std::string(Path.str());
 }
 

clang/lib/Driver/ToolChains/BareMetal.cpp

if (TargetTriple.isRISCV64()) {
 
     addMultilibFlag((Arch == "rv64imac"), "-march=rv64imac", Flags);
     addMultilibFlag(UseImafdc, "-march=rv64imafdc", Flags);
     addMultilibFlag(Abi == "lp64", "-mabi=lp64", Flags);
     addMultilibFlag(Abi == "lp64d", "-mabi=lp64d", Flags);
 
     Result.Multilibs =
         MultilibSetBuilder().Either(Imac, Imafdc).makeMultilibSet();
-    return Result.Multilibs.select(Flags, Result.SelectedMultilib);
+    return Result.Multilibs.select(Flags, Result.SelectedMultilibs);
   }
   if (TargetTriple.isRISCV32()) {
     MultilibBuilder Imac =
         MultilibBuilder().flag("-march=rv32imac").flag("-mabi=ilp32");
     MultilibBuilder I = MultilibBuilder("/rv32i/ilp32")
                             .flag("-march=rv32i")
                             .flag("-mabi=ilp32");
     MultilibBuilder Im = MultilibBuilder("/rv32im/ilp32")
if (TargetTriple.isRISCV32()) {
     addMultilibFlag((Arch == "rv32iac"), "-march=rv32iac", Flags);
     addMultilibFlag((Arch == "rv32imac"), "-march=rv32imac", Flags);
     addMultilibFlag(UseImafc, "-march=rv32imafc", Flags);
     addMultilibFlag(Abi == "ilp32", "-mabi=ilp32", Flags);
     addMultilibFlag(Abi == "ilp32f", "-mabi=ilp32f", Flags);
 
     Result.Multilibs =
         MultilibSetBuilder().Either(I, Im, Iac, Imac, Imafc).makeMultilibSet();
-    return Result.Multilibs.select(Flags, Result.SelectedMultilib);
+    return Result.Multilibs.select(Flags, Result.SelectedMultilibs);
   }
   return false;
 }
 
 BareMetal::BareMetal(const Driver &D, const llvm::Triple &Triple,
                      const ArgList &Args)
     : ToolChain(D, Triple, Args) {
   getProgramPaths().push_back(getDriver().getInstalledDir());
static bool findMultilibsFromYAML(const ToolChain &TC, const Driver &D,
   if (!MB)
     return false;
   Multilib::flags_list Flags = TC.getMultilibFlags(Args);
   llvm::ErrorOr<MultilibSet> ErrorOrMultilibSet =
       MultilibSet::parseYaml(*MB.get());
   if (ErrorOrMultilibSet.getError())
     return false;
   Result.Multilibs = ErrorOrMultilibSet.get();
-  return Result.Multilibs.select(Flags, Result.SelectedMultilib);
+  return Result.Multilibs.select(Flags, Result.SelectedMultilibs);
 }
 
 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())
static std::string computeBaseSysRoot(const Driver &D,
   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)) {
-      SelectedMultilib = Result.SelectedMultilib;
+      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);
-    SelectedMultilib = Result.SelectedMultilib;
+    SelectedMultilibs = Result.SelectedMultilibs;
     Multilibs = Result.Multilibs;
   }
 }
 
 bool BareMetal::handlesTarget(const llvm::Triple &Triple) {
   return isARMBareMetal(Triple) || isAArch64BareMetal(Triple) ||
          isRISCVBareMetal(Triple);
 }
 
 Tool *BareMetal::buildLinker() const {
   return new tools::baremetal::Linker(*this);
 }
 
 std::string BareMetal::computeSysRoot() const {
-  return computeBaseSysRoot(getDriver(), getTriple()) +
-         SelectedMultilib.osSuffix();
+  std::string Result = computeBaseSysRoot(getDriver(), getTriple());
+  if (!SelectedMultilibs.empty())
+    Result += SelectedMultilibs.back().osSuffix();
+  return Result;
 }
 
 void BareMetal::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
                                           ArgStringList &CC1Args) const {
   if (DriverArgs.hasArg(options::OPT_nostdinc))
     return;
 
   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {

clang/lib/Driver/ToolChains/CSKYToolChain.cpp

 
 /// CSKY Toolchain
 CSKYToolChain::CSKYToolChain(const Driver &D, const llvm::Triple &Triple,
                              const ArgList &Args)
     : Generic_ELF(D, Triple, Args) {
   GCCInstallation.init(Triple, Args);
   if (GCCInstallation.isValid()) {
     Multilibs = GCCInstallation.getMultilibs();
-    SelectedMultilib = GCCInstallation.getMultilib();
+    SelectedMultilibs.assign({GCCInstallation.getMultilib()});
     path_list &Paths = getFilePaths();
     // Add toolchain/multilib specific file paths.
-    addMultilibsFilePaths(D, Multilibs, SelectedMultilib,
+    addMultilibsFilePaths(D, Multilibs, SelectedMultilibs.back(),
                           GCCInstallation.getInstallPath(), Paths);
     getFilePaths().push_back(GCCInstallation.getInstallPath().str() +
-                             SelectedMultilib.osSuffix());
+                             SelectedMultilibs.back().osSuffix());
     ToolChain::path_list &PPaths = getProgramPaths();
     // Multilib cross-compiler GCC installations put ld in a triple-prefixed
     // directory off of the parent of the GCC installation.
     PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
                            GCCInstallation.getTriple().str() + "/bin")
                          .str());
     PPaths.push_back((GCCInstallation.getParentLibPath() + "/../bin").str());
+    getFilePaths().push_back(computeSysRoot() + "/lib" +
+                             SelectedMultilibs.back().osSuffix());
   } else {
     getProgramPaths().push_back(D.Dir);
+    getFilePaths().push_back(computeSysRoot() + "/lib");
   }
-  getFilePaths().push_back(computeSysRoot() + "/lib" +
-                           SelectedMultilib.osSuffix());
 }
 
 Tool *CSKYToolChain::buildLinker() const {
   return new tools::CSKY::Linker(*this);
 }
 
 ToolChain::RuntimeLibType CSKYToolChain::GetDefaultRuntimeLibType() const {
   return GCCInstallation.isValid() ? ToolChain::RLT_Libgcc

clang/lib/Driver/ToolChains/Fuchsia.cpp

Fuchsia::Fuchsia(const Driver &D, const llvm::Triple &Triple,
   addMultilibFlag(getSanitizerArgs(Args).needsHwasanRt(),
                   "-fsanitize=hwaddress", Flags);
 
   addMultilibFlag(Args.getLastArgValue(options::OPT_fcxx_abi_EQ) == "itanium",
                   "-fc++-abi=itanium", Flags);
 
   Multilibs.setFilePathsCallback(FilePaths);
 
-  if (Multilibs.select(Flags, SelectedMultilib))
-    if (!SelectedMultilib.isDefault())
+  if (Multilibs.select(Flags, SelectedMultilibs)) {
+    // Ensure that -print-multi-directory only outputs one multilib directory.
+    Multilib LastSelected = SelectedMultilibs.back();
+    SelectedMultilibs = {LastSelected};
+
+    if (!SelectedMultilibs.back().isDefault())
       if (const auto &PathsCallback = Multilibs.filePathsCallback())
-        for (const auto &Path : PathsCallback(SelectedMultilib))
+        for (const auto &Path : PathsCallback(SelectedMultilibs.back()))
           // Prepend the multilib path to ensure it takes the precedence.
           getFilePaths().insert(getFilePaths().begin(), Path);
   }
+}
 
 std::string Fuchsia::ComputeEffectiveClangTriple(const ArgList &Args,
                                                  types::ID InputType) const {
   llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
   return Triple.str();
 }
 
 Tool *Fuchsia::buildLinker() const {

clang/lib/Driver/ToolChains/Gnu.h

 
 namespace clang {
 namespace driver {
 
 struct DetectedMultilibs {
   /// The set of multilibs that the detected installation supports.
   MultilibSet Multilibs;
 
-  /// The primary multilib appropriate for the given flags.
-  Multilib SelectedMultilib;
+  /// The multilibs appropriate for the given flags.
+  llvm::SmallVector<Multilib> SelectedMultilibs;
 
   /// On Biarch systems, this corresponds to the default multilib when
   /// targeting the non-default multilib. Otherwise, it is empty.
   std::optional<Multilib> BiarchSibling;
 };
 
 bool findMIPSMultilibs(const Driver &D, const llvm::Triple &TargetTriple,
                        StringRef Path, const llvm::opt::ArgList &Args,

clang/lib/Driver/ToolChains/Gnu.cpp

static bool findMipsCsMultilibs(const Multilib::flags_list &Flags,
   }
 
   // Sort candidates. Toolchain that best meets the directories tree goes first.
   // Then select the first toolchains matches command line flags.
   MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
   if (CSMipsMultilibs.size() < DebianMipsMultilibs.size())
     std::iter_swap(Candidates, Candidates + 1);
   for (const MultilibSet *Candidate : Candidates) {
-    if (Candidate->select(Flags, Result.SelectedMultilib)) {
+    if (Candidate->select(Flags, Result.SelectedMultilibs)) {
       if (Candidate == &DebianMipsMultilibs)
         Result.BiarchSibling = Multilib();
       Result.Multilibs = *Candidate;
       return true;
     }
   }
   return false;
 }
MultilibSet AndroidMips64elMultilibs =
           .makeMultilibSet()
           .FilterOut(NonExistent);
 
   MultilibSet *MS = &AndroidMipsMultilibs;
   if (VFS.exists(Path + "/mips-r6"))
     MS = &AndroidMipselMultilibs;
   else if (VFS.exists(Path + "/32"))
     MS = &AndroidMips64elMultilibs;
-  if (MS->select(Flags, Result.SelectedMultilib)) {
+  if (MS->select(Flags, Result.SelectedMultilibs)) {
     Result.Multilibs = *MS;
     return true;
   }
   return false;
 }
 
 static bool findMipsMuslMultilibs(const Multilib::flags_list &Flags,
                                   FilterNonExistent &NonExistent,
MuslMipsMultilibs = MultilibSetBuilder()
                             .makeMultilibSet();
 
     // Specify the callback that computes the include directories.
     MuslMipsMultilibs.setIncludeDirsCallback([](const Multilib &M) {
       return std::vector<std::string>(
           {"/../sysroot" + M.osSuffix() + "/usr/include"});
     });
   }
-  if (MuslMipsMultilibs.select(Flags, Result.SelectedMultilib)) {
+  if (MuslMipsMultilibs.select(Flags, Result.SelectedMultilibs)) {
     Result.Multilibs = MuslMipsMultilibs;
     return true;
   }
   return false;
 }
 
 static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags,
                                  FilterNonExistent &NonExistent,
MtiMipsMultilibsV2 =
                                                "/../usr/include"});
             })
             .setFilePathsCallback([](const Multilib &M) {
               return std::vector<std::string>(
                   {"/../../../../mips-mti-linux-gnu/lib" + M.gccSuffix()});
             });
   }
   for (auto *Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
-    if (Candidate->select(Flags, Result.SelectedMultilib)) {
+    if (Candidate->select(Flags, Result.SelectedMultilibs)) {
       Result.Multilibs = *Candidate;
       return true;
     }
   }
   return false;
 }
 
 static bool findMipsImgMultilibs(const Multilib::flags_list &Flags,
ImgMultilibsV2 =
                                                "/../usr/include"});
             })
             .setFilePathsCallback([](const Multilib &M) {
               return std::vector<std::string>(
                   {"/../../../../mips-img-linux-gnu/lib" + M.gccSuffix()});
             });
   }
   for (auto *Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
-    if (Candidate->select(Flags, Result.SelectedMultilib)) {
+    if (Candidate->select(Flags, Result.SelectedMultilibs)) {
       Result.Multilibs = *Candidate;
       return true;
     }
   }
   return false;
 }
 
 bool clang::driver::findMIPSMultilibs(const Driver &D,
bool clang::driver::findMIPSMultilibs(const Driver &D,
   if (findMipsCsMultilibs(Flags, NonExistent, Result))
     return true;
 
   // Fallback to the regular toolchain-tree structure.
   Multilib Default;
   Result.Multilibs.push_back(Default);
   Result.Multilibs.FilterOut(NonExistent);
 
-  if (Result.Multilibs.select(Flags, Result.SelectedMultilib)) {
+  if (Result.Multilibs.select(Flags, Result.SelectedMultilibs)) {
     Result.BiarchSibling = Multilib();
     return true;
   }
 
   return false;
 }
 
 static void findAndroidArmMultilibs(const Driver &D,
bool IsThumbMode = IsThumbArch ||
       Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, false) ||
       (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::ISAKind::THUMB);
   bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
       (llvm::ARM::parseArchVersion(Arch) == 7 ||
        (IsArmArch && Arch == "" && IsV7SubArch));
   addMultilibFlag(IsArmV7Mode, "-march=armv7-a", Flags);
   addMultilibFlag(IsThumbMode, "-mthumb", Flags);
 
-  if (AndroidArmMultilibs.select(Flags, Result.SelectedMultilib))
+  if (AndroidArmMultilibs.select(Flags, Result.SelectedMultilibs))
     Result.Multilibs = AndroidArmMultilibs;
 }
 
 static bool findMSP430Multilibs(const Driver &D,
                                 const llvm::Triple &TargetTriple,
                                 StringRef Path, const ArgList &Args,
                                 DetectedMultilibs &Result) {
   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
static bool findMSP430Multilibs(const Driver &D,
   Result.Multilibs.push_back(WithoutExceptions.makeMultilib());
   Result.Multilibs.push_back(WithExceptions.makeMultilib());
   Result.Multilibs.FilterOut(NonExistent);
 
   Multilib::flags_list Flags;
   addMultilibFlag(Args.hasFlag(options::OPT_fexceptions,
                                options::OPT_fno_exceptions, false),
                   "-exceptions", Flags);
-  if (Result.Multilibs.select(Flags, Result.SelectedMultilib))
+  if (Result.Multilibs.select(Flags, Result.SelectedMultilibs))
     return true;
 
   return false;
 }
 
 static void findCSKYMultilibs(const Driver &D, const llvm::Triple &TargetTriple,
                               StringRef Path, const ArgList &Args,
                               DetectedMultilibs &Result) {
MultilibSet CSKYMultilibs =
       MultilibSetBuilder()
           .Maybe(BigEndian)
           .Either({Arch801, Arch802, Arch803, Arch804, Arch805, Arch807,
                    Arch810, Arch810v, Arch860, Arch860v})
           .Either(HardFloat, SoftFpFloat, SoftFloat)
           .makeMultilibSet()
           .FilterOut(NonExistent);
 
-  if (CSKYMultilibs.select(Flags, Result.SelectedMultilib))
+  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) {
   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
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.SelectedMultilib))
+  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) {
   if (TargetTriple.getOS() == llvm::Triple::UnknownOS)
     return findRISCVBareMetalMultilibs(D, TargetTriple, Path, Args, Result);
static void findRISCVMultilibs(const Driver &D,
   addMultilibFlag(IsRV64, "-m64", Flags);
   addMultilibFlag(ABIName == "ilp32", "-mabi=ilp32", Flags);
   addMultilibFlag(ABIName == "ilp32f", "-mabi=ilp32f", Flags);
   addMultilibFlag(ABIName == "ilp32d", "-mabi=ilp32d", Flags);
   addMultilibFlag(ABIName == "lp64", "-mabi=lp64", Flags);
   addMultilibFlag(ABIName == "lp64f", "-mabi=lp64f", Flags);
   addMultilibFlag(ABIName == "lp64d", "-mabi=lp64d", Flags);
 
-  if (RISCVMultilibs.select(Flags, Result.SelectedMultilib))
+  if (RISCVMultilibs.select(Flags, Result.SelectedMultilibs))
     Result.Multilibs = RISCVMultilibs;
 }
 
 static bool findBiarchMultilibs(const Driver &D,
                                 const llvm::Triple &TargetTriple,
                                 StringRef Path, const ArgList &Args,
                                 bool NeedsBiarchSuffix,
                                 DetectedMultilibs &Result) {
static bool findBiarchMultilibs(const Driver &D,
 
   Result.Multilibs.FilterOut(NonExistent);
 
   Multilib::flags_list Flags;
   addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32, "-m64", Flags);
   addMultilibFlag(TargetTriple.isArch32Bit(), "-m32", Flags);
   addMultilibFlag(TargetTriple.isArch64Bit() && IsX32, "-mx32", Flags);
 
-  if (!Result.Multilibs.select(Flags, Result.SelectedMultilib))
+  if (!Result.Multilibs.select(Flags, Result.SelectedMultilibs))
     return false;
 
-  if (Result.SelectedMultilib == Alt64 || Result.SelectedMultilib == Alt32 ||
-      Result.SelectedMultilib == Altx32)
+  if (Result.SelectedMultilibs.back() == Alt64 ||
+      Result.SelectedMultilibs.back() == Alt32 ||
+      Result.SelectedMultilibs.back() == Altx32)
     Result.BiarchSibling = Default;
 
   return true;
 }
 
 /// Generic_GCC - A tool chain using the 'gcc' command to perform
 /// all subcommands; this relies on gcc translating the majority of
 /// command line options.
bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
   } else if (TargetArch == llvm::Triple::avr) {
     // AVR has no multilibs.
   } else if (!findBiarchMultilibs(D, TargetTriple, Path, Args,
                                   NeedsBiarchSuffix, Detected)) {
     return false;
   }
 
   Multilibs = Detected.Multilibs;
-  SelectedMultilib = Detected.SelectedMultilib;
+  SelectedMultilib = Detected.SelectedMultilibs.empty()
+                         ? Multilib()
+                         : Detected.SelectedMultilibs.back();
   BiarchSibling = Detected.BiarchSibling;
 
   return true;
 }
 
 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
     const llvm::Triple &TargetTriple, const ArgList &Args,
     const std::string &LibDir, StringRef CandidateTriple,

 
 void Generic_GCC::AddMultilibPaths(const Driver &D,
                                    const std::string &SysRoot,
                                    const std::string &OSLibDir,
                                    const std::string &MultiarchTriple,
                                    path_list &Paths) {
   // Add the multilib suffixed paths where they are available.
   if (GCCInstallation.isValid()) {
+    assert(!SelectedMultilibs.empty());
     const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
     const std::string &LibPath =
         std::string(GCCInstallation.getParentLibPath());
 
     // Sourcery CodeBench MIPS toolchain holds some libraries under
     // a biarch-like suffix of the GCC installation.
     if (const auto &PathsCallback = Multilibs.filePathsCallback())
-      for (const auto &Path : PathsCallback(SelectedMultilib))
+      for (const auto &Path : PathsCallback(SelectedMultilibs.back()))
         addPathIfExists(D, GCCInstallation.getInstallPath() + Path, Paths);
 
     // Add lib/gcc/$triple/$version, with an optional /multilib suffix.
-    addPathIfExists(
-        D, GCCInstallation.getInstallPath() + SelectedMultilib.gccSuffix(),
+    addPathIfExists(D,
+                    GCCInstallation.getInstallPath() +
+                        SelectedMultilibs.back().gccSuffix(),
                     Paths);
 
     // Add lib/gcc/$triple/$libdir
     // For GCC built with --enable-version-specific-runtime-libs.
     addPathIfExists(D, GCCInstallation.getInstallPath() + "/../" + OSLibDir,
                     Paths);
 
     // GCC cross compiling toolchains will install target libraries which ship
     // as part of the toolchain under <prefix>/<triple>/<libdir> rather than as
if (GCCInstallation.isValid()) {
     //  2) There must not be libraries installed into
     //     <prefix>/<triple>/<libdir> unless they should be preferred over
     //     those within the system root.
     //
     // Note that this matches the GCC behavior. See the below comment for where
     // Clang diverges from GCC's behavior.
     addPathIfExists(D,
                     LibPath + "/../" + GCCTriple.str() + "/lib/../" + OSLibDir +
-                        SelectedMultilib.osSuffix(),
+                        SelectedMultilibs.back().osSuffix(),
                     Paths);
 
     // If the GCC installation we found is inside of the sysroot, we want to
     // prefer libraries installed in the parent prefix of the GCC installation.
     // It is important to *not* use these paths when the GCC installation is
     // outside of the system root as that can pick up unintended libraries.
     // This usually happens when there is an external cross compiler on the
     // host system, and a more minimal sysroot available that is the target of

clang/lib/Driver/ToolChains/Hexagon.cpp

if (!Gn.getAsInteger(10, G))
     return G;
 
   return std::nullopt;
 }
 
 std::string HexagonToolChain::getCompilerRTPath() const {
   SmallString<128> Dir(getDriver().SysRoot);
   llvm::sys::path::append(Dir, "usr", "lib");
-  Dir += SelectedMultilib.gccSuffix();
+  if (!SelectedMultilibs.empty()) {
+    Dir += SelectedMultilibs.back().gccSuffix();
+  }
   return std::string(Dir.str());
 }
 
 void HexagonToolChain::getHexagonLibraryPaths(const ArgList &Args,
       ToolChain::path_list &LibPaths) const {
   const Driver &D = getDriver();
 
   //----------------------------------------------------------------------------

clang/lib/Driver/ToolChains/Hurd.cpp

static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {
 
   return Triple.isArch32Bit() ? "lib" : "lib64";
 }
 
 Hurd::Hurd(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
     : Generic_ELF(D, Triple, Args) {
   GCCInstallation.init(Triple, Args);
   Multilibs = GCCInstallation.getMultilibs();
-  SelectedMultilib = GCCInstallation.getMultilib();
+  SelectedMultilibs.assign({GCCInstallation.getMultilib()});
   std::string SysRoot = computeSysRoot();
   ToolChain::path_list &PPaths = getProgramPaths();
 
   Generic_GCC::PushPPaths(PPaths);
 
   // The selection of paths to try here is designed to match the patterns which
   // the GCC driver itself uses, as this is part of the GCC-compatible driver.
   // This was determined by running GCC in a fake filesystem, creating all

clang/lib/Driver/ToolChains/Linux.cpp

static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {
 
   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);
   Multilibs = GCCInstallation.getMultilibs();
-  SelectedMultilib = GCCInstallation.getMultilib();
+  SelectedMultilibs.assign({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 (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
     ExtraOpts.push_back("-X");
 
   const bool IsAndroid = Triple.isAndroid();
   const bool IsMips = Triple.isMIPS();
   const bool IsHexagon = Arch == llvm::Triple::hexagon;
   const bool IsRISCV = Triple.isRISCV();
   const bool IsCSKY = Triple.isCSKY();
 
-  if (IsCSKY)
-    SysRoot = SysRoot + SelectedMultilib.osSuffix();
+  if (IsCSKY && !SelectedMultilibs.empty())
+    SysRoot = SysRoot + SelectedMultilibs.back().osSuffix();
 
   if ((IsMips || IsCSKY) && !SysRoot.empty())
     ExtraOpts.push_back("--sysroot=" + SysRoot);
 
   // Do not use 'gnu' hash style for Mips targets because .gnu.hash
   // and the MIPS ABI require .dynsym to be sorted in different ways.
   // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
   // ABI requires a mapping between the GOT and the symbol table.

clang/lib/Driver/ToolChains/MipsLinux.cpp

 MipsLLVMToolChain::MipsLLVMToolChain(const Driver &D,
                                      const llvm::Triple &Triple,
                                      const ArgList &Args)
     : Linux(D, Triple, Args) {
   // Select the correct multilib according to the given arguments.
   DetectedMultilibs Result;
   findMIPSMultilibs(D, Triple, "", Args, Result);
   Multilibs = Result.Multilibs;
-  SelectedMultilib = Result.SelectedMultilib;
+  SelectedMultilibs = Result.SelectedMultilibs;
 
   // Find out the library suffix based on the ABI.
   LibSuffix = tools::mips::getMipsABILibSuffix(Args, Triple);
   getFilePaths().clear();
   getFilePaths().push_back(computeSysRoot() + "/usr/lib" + LibSuffix);
 }
 
 void MipsLLVMToolChain::AddClangSystemIncludeArgs(

clang/lib/Driver/ToolChains/OHOS.cpp

static bool findOHOSMuslMultilibs(const Multilib::flags_list &Flags,
   Multilibs.push_back(
       Multilib("/a7_softfp_neon-vfpv4", {}, {},
                {"-mcpu=cortex-a7", "-mfloat-abi=softfp", "-mfpu=neon-vfpv4"}));
 
   Multilibs.push_back(
       Multilib("/a7_hard_neon-vfpv4", {}, {},
                {"-mcpu=cortex-a7", "-mfloat-abi=hard", "-mfpu=neon-vfpv4"}));
 
-  if (Multilibs.select(Flags, Result.SelectedMultilib)) {
+  if (Multilibs.select(Flags, Result.SelectedMultilibs)) {
     Result.Multilibs = Multilibs;
     return true;
   }
   return false;
 }
 
 static bool findOHOSMultilibs(const Driver &D,
                                       const ToolChain &TC,

 OHOS::OHOS(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
     : Generic_ELF(D, Triple, Args) {
   std::string SysRoot = computeSysRoot();
 
   // Select the correct multilib according to the given arguments.
   DetectedMultilibs Result;
   findOHOSMultilibs(D, *this, Triple, "", Args, Result);
   Multilibs = Result.Multilibs;
-  SelectedMultilib = Result.SelectedMultilib;
+  SelectedMultilibs = Result.SelectedMultilibs;
+  if (!SelectedMultilibs.empty()) {
+    SelectedMultilib = SelectedMultilibs.back();
+  }
 
   getFilePaths().clear();
   for (const auto &CandidateLibPath : getArchSpecificLibPaths())
     if (getVFS().exists(CandidateLibPath))
       getFilePaths().push_back(CandidateLibPath);
 
   getLibraryPaths().clear();
   for (auto &Path : getRuntimePaths())

clang/lib/Driver/ToolChains/RISCVToolchain.cpp

 
 /// RISC-V Toolchain
 RISCVToolChain::RISCVToolChain(const Driver &D, const llvm::Triple &Triple,
                                const ArgList &Args)
     : Generic_ELF(D, Triple, Args) {
   GCCInstallation.init(Triple, Args);
   if (GCCInstallation.isValid()) {
     Multilibs = GCCInstallation.getMultilibs();
-    SelectedMultilib = GCCInstallation.getMultilib();
+    SelectedMultilibs.assign({GCCInstallation.getMultilib()});
     path_list &Paths = getFilePaths();
     // Add toolchain/multilib specific file paths.
-    addMultilibsFilePaths(D, Multilibs, SelectedMultilib,
+    addMultilibsFilePaths(D, Multilibs, SelectedMultilibs.back(),
                           GCCInstallation.getInstallPath(), Paths);
     getFilePaths().push_back(GCCInstallation.getInstallPath().str());
     ToolChain::path_list &PPaths = getProgramPaths();
     // Multilib cross-compiler GCC installations put ld in a triple-prefixed
     // directory off of the parent of the GCC installation.
     PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
                            GCCInstallation.getTriple().str() + "/bin")
                          .str());

clang/test/Driver/fuchsia.cpp

 // CHECK-MULTILIB-X86: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
 // CHECK-MULTILIB-ASAN-X86: "-L{{.*}}{{/|\\\\}}..{{/|\\\\}}lib{{/|\\\\}}x86_64-unknown-fuchsia{{/|\\\\}}asan"
 // CHECK-MULTILIB-NOEXCEPT-X86: "-L{{.*}}{{/|\\\\}}..{{/|\\\\}}lib{{/|\\\\}}x86_64-unknown-fuchsia{{/|\\\\}}noexcept"
 // CHECK-MULTILIB-ASAN-NOEXCEPT-X86: "-L{{.*}}{{/|\\\\}}..{{/|\\\\}}lib{{/|\\\\}}x86_64-unknown-fuchsia{{/|\\\\}}asan+noexcept"
 // CHECK-MULTILIB-HWASAN-X86: "-L{{.*}}{{/|\\\\}}..{{/|\\\\}}lib{{/|\\\\}}x86_64-unknown-fuchsia{{/|\\\\}}hwasan"
 // CHECK-MULTILIB-HWASAN-NOEXCEPT-X86: "-L{{.*}}{{/|\\\\}}..{{/|\\\\}}lib{{/|\\\\}}x86_64-unknown-fuchsia{{/|\\\\}}hwasan+noexcept"
 // CHECK-MULTILIB-COMPAT-X86: "-L{{.*}}{{/|\\\\}}..{{/|\\\\}}lib{{/|\\\\}}x86_64-unknown-fuchsia{{/|\\\\}}compat"
 // CHECK-MULTILIB-X86: "-L{{.*}}{{/|\\\\}}..{{/|\\\\}}lib{{/|\\\\}}x86_64-unknown-fuchsia"
+
+// Check that -print-multi-directory only outputs one multilib directory.
+// This may be relaxed later but for now preserve existing behaviour.
+// RUN: %clangxx -print-multi-directory --target=x86_64-unknown-fuchsia -fsanitize=address -fno-exceptions \
+// RUN:     -ccc-install-dir %S/Inputs/basic_fuchsia_tree/bin \
+// RUN:     -resource-dir=%S/Inputs/resource_dir_with_per_target_subdir \
+// RUN:     | FileCheck %s -check-prefixes=CHECK-PRINT-MULTI-LIB
+// CHECK-PRINT-MULTI-LIB-NOT: .
+// CHECK-PRINT-MULTI-LIB-NOT: noexcept
+// CHECK-PRINT-MULTI-LIB-NOT: asan
+// CHECK-PRINT-MULTI-LIB: asan+noexcept

clang/unittests/Driver/MultilibBuilderTest.cpp

 }
 
 TEST(MultilibBuilderTest, SetSelection1) {
   MultilibSet MS1 = MultilibSetBuilder()
                         .Maybe(MultilibBuilder("64").flag("-m64"))
                         .makeMultilibSet();
 
   Multilib::flags_list FlagM64 = {"-m64"};
-  Multilib SelectionM64;
+  llvm::SmallVector<Multilib> SelectionM64;
   ASSERT_TRUE(MS1.select(FlagM64, SelectionM64))
       << "Flag set was {\"-m64\"}, but selection not found";
-  ASSERT_TRUE(SelectionM64.gccSuffix() == "/64")
-      << "Selection picked " << SelectionM64 << " which was not expected";
+  ASSERT_TRUE(SelectionM64.back().gccSuffix() == "/64")
+      << "Selection picked " << SelectionM64.back()
+      << " which was not expected";
 
   Multilib::flags_list FlagNoM64 = {"!m64"};
-  Multilib SelectionNoM64;
+  llvm::SmallVector<Multilib> SelectionNoM64;
   ASSERT_TRUE(MS1.select(FlagNoM64, SelectionNoM64))
       << "Flag set was {\"!m64\"}, but selection not found";
-  ASSERT_TRUE(SelectionNoM64.gccSuffix() == "")
-      << "Selection picked " << SelectionNoM64 << " which was not expected";
+  ASSERT_TRUE(SelectionNoM64.back().gccSuffix() == "")
+      << "Selection picked " << SelectionNoM64.back()
+      << " which was not expected";
 }
 
 TEST(MultilibBuilderTest, SetSelection2) {
   MultilibSet MS2 = MultilibSetBuilder()
                         .Maybe(MultilibBuilder("el").flag("-EL"))
                         .Maybe(MultilibBuilder("sf").flag("-SF"))
                         .makeMultilibSet();
 
   for (unsigned I = 0; I < 4; ++I) {
     bool IsEL = I & 0x1;
     bool IsSF = I & 0x2;
     Multilib::flags_list Flags;
     if (IsEL)
       Flags.push_back("-EL");
     else
       Flags.push_back("!EL");
 
     if (IsSF)
       Flags.push_back("-SF");
     else
       Flags.push_back("!SF");
 
-    Multilib Selection;
+    llvm::SmallVector<Multilib> Selection;
     ASSERT_TRUE(MS2.select(Flags, Selection))
         << "Selection failed for " << (IsEL ? "-EL" : "!EL") << " "
         << (IsSF ? "-SF" : "!SF");
 
     std::string Suffix;
     if (IsEL)
       Suffix += "/el";
     if (IsSF)
       Suffix += "/sf";
 
-    ASSERT_EQ(Selection.gccSuffix(), Suffix)
-        << "Selection picked " << Selection << " which was not expected ";
+    ASSERT_EQ(Selection.back().gccSuffix(), Suffix)
+        << "Selection picked " << Selection.back()
+        << " which was not expected ";
   }
 }

clang/unittests/Driver/MultilibTest.cpp

 }
 
 TEST(MultilibTest, SetPriority) {
   MultilibSet MS({
       Multilib("/foo", {}, {}, {"+foo"}),
       Multilib("/bar", {}, {}, {"+bar"}),
   });
   Multilib::flags_list Flags1 = {"+foo", "-bar"};
-  Multilib Selection1;
+  llvm::SmallVector<Multilib> Selection1;
   ASSERT_TRUE(MS.select(Flags1, Selection1))
       << "Flag set was {\"+foo\"}, but selection not found";
-  ASSERT_TRUE(Selection1.gccSuffix() == "/foo")
-      << "Selection picked " << Selection1 << " which was not expected";
+  ASSERT_TRUE(Selection1.back().gccSuffix() == "/foo")
+      << "Selection picked " << Selection1.back() << " which was not expected";
 
   Multilib::flags_list Flags2 = {"+foo", "+bar"};
-  Multilib Selection2;
+  llvm::SmallVector<Multilib> Selection2;
   ASSERT_TRUE(MS.select(Flags2, Selection2))
       << "Flag set was {\"+bar\"}, but selection not found";
-  ASSERT_TRUE(Selection2.gccSuffix() == "/bar")
-      << "Selection picked " << Selection2 << " which was not expected";
+  ASSERT_TRUE(Selection2.back().gccSuffix() == "/bar")
+      << "Selection picked " << Selection2.back() << " which was not expected";
 }
 
 TEST(MultilibTest, SelectMultiple) {
   MultilibSet MS({
       Multilib("/a", {}, {}, {"x"}),
       Multilib("/b", {}, {}, {"y"}),
   });
-  std::vector<Multilib> Selection;
+  llvm::SmallVector<Multilib> Selection;
 
-  Selection = MS.select({"x"});
+  ASSERT_TRUE(MS.select({"x"}, Selection));
   ASSERT_EQ(1u, Selection.size());
   EXPECT_EQ("/a", Selection[0].gccSuffix());
 
-  Selection = MS.select({"y"});
+  ASSERT_TRUE(MS.select({"y"}, Selection));
   ASSERT_EQ(1u, Selection.size());
   EXPECT_EQ("/b", Selection[0].gccSuffix());
 
-  Selection = MS.select({"y", "x"});
+  ASSERT_TRUE(MS.select({"y", "x"}, Selection));
   ASSERT_EQ(2u, Selection.size());
   EXPECT_EQ("/a", Selection[0].gccSuffix());
   EXPECT_EQ("/b", Selection[1].gccSuffix());
 }
 
 static void diagnosticCallback(const llvm::SMDiagnostic &D, void *Out) {
   *reinterpret_cast<std::string *>(Out) = D.getMessage();
 }

 - Dir: b
   Flags: []
 )"));
   EXPECT_EQ(2U, MS.size());
 }
 
 TEST(MultilibTest, SelectSoft) {
   MultilibSet MS;
-  Multilib Selected;
+  llvm::SmallVector<Multilib> Selected;
   ASSERT_TRUE(parseYaml(MS, YAML_PREAMBLE R"(
 Variants:
 - Dir: s
   Flags: [-mfloat-abi=soft]
 Mappings:
 - Match: -mfloat-abi=softfp
   Flags: [-mfloat-abi=soft]
 )"));
   EXPECT_TRUE(MS.select({"-mfloat-abi=soft"}, Selected));
   EXPECT_TRUE(MS.select({"-mfloat-abi=softfp"}, Selected));
   EXPECT_FALSE(MS.select({"-mfloat-abi=hard"}, Selected));
 }
 
 TEST(MultilibTest, SelectSoftFP) {
   MultilibSet MS;
-  Multilib Selected;
+  llvm::SmallVector<Multilib> Selected;
   ASSERT_TRUE(parseYaml(MS, YAML_PREAMBLE R"(
 Variants:
 - Dir: f
   Flags: [-mfloat-abi=softfp]
 )"));
   EXPECT_FALSE(MS.select({"-mfloat-abi=soft"}, Selected));
   EXPECT_TRUE(MS.select({"-mfloat-abi=softfp"}, Selected));
   EXPECT_FALSE(MS.select({"-mfloat-abi=hard"}, Selected));
 }
 
 TEST(MultilibTest, SelectHard) {
   // If hard float is all that's available then select that only if compiling
   // with hard float.
   MultilibSet MS;
-  Multilib Selected;
+  llvm::SmallVector<Multilib> Selected;
   ASSERT_TRUE(parseYaml(MS, YAML_PREAMBLE R"(
 Variants:
 - Dir: h
   Flags: [-mfloat-abi=hard]
 )"));
   EXPECT_FALSE(MS.select({"-mfloat-abi=soft"}, Selected));
   EXPECT_FALSE(MS.select({"-mfloat-abi=softfp"}, Selected));
   EXPECT_TRUE(MS.select({"-mfloat-abi=hard"}, Selected));
 }
 
 TEST(MultilibTest, SelectFloatABI) {
   MultilibSet MS;
-  Multilib Selected;
+  llvm::SmallVector<Multilib> Selected;
   ASSERT_TRUE(parseYaml(MS, YAML_PREAMBLE R"(
 Variants:
 - Dir: s
   Flags: [-mfloat-abi=soft]
 - Dir: f
   Flags: [-mfloat-abi=softfp]
 - Dir: h
   Flags: [-mfloat-abi=hard]
 Mappings:
 - Match: -mfloat-abi=softfp
   Flags: [-mfloat-abi=soft]
 )"));
   MS.select({"-mfloat-abi=soft"}, Selected);
-  EXPECT_EQ("/s", Selected.gccSuffix());
+  EXPECT_EQ("/s", Selected.back().gccSuffix());
   MS.select({"-mfloat-abi=softfp"}, Selected);
-  EXPECT_EQ("/f", Selected.gccSuffix());
+  EXPECT_EQ("/f", Selected.back().gccSuffix());
   MS.select({"-mfloat-abi=hard"}, Selected);
-  EXPECT_EQ("/h", Selected.gccSuffix());
+  EXPECT_EQ("/h", Selected.back().gccSuffix());
 }
 
 TEST(MultilibTest, SelectFloatABIReversed) {
   // If soft is specified after softfp then softfp will never be
   // selected because soft is compatible with softfp and last wins.
   MultilibSet MS;
-  Multilib Selected;
+  llvm::SmallVector<Multilib> Selected;
   ASSERT_TRUE(parseYaml(MS, YAML_PREAMBLE R"(
 Variants:
 - Dir: h
   Flags: [-mfloat-abi=hard]
 - Dir: f
   Flags: [-mfloat-abi=softfp]
 - Dir: s
   Flags: [-mfloat-abi=soft]
 Mappings:
 - Match: -mfloat-abi=softfp
   Flags: [-mfloat-abi=soft]
 )"));
   MS.select({"-mfloat-abi=soft"}, Selected);
-  EXPECT_EQ("/s", Selected.gccSuffix());
+  EXPECT_EQ("/s", Selected.back().gccSuffix());
   MS.select({"-mfloat-abi=softfp"}, Selected);
-  EXPECT_EQ("/s", Selected.gccSuffix());
+  EXPECT_EQ("/s", Selected.back().gccSuffix());
   MS.select({"-mfloat-abi=hard"}, Selected);
-  EXPECT_EQ("/h", Selected.gccSuffix());
+  EXPECT_EQ("/h", Selected.back().gccSuffix());
 }
 
 TEST(MultilibTest, SelectMClass) {
   const char *MultilibSpec = YAML_PREAMBLE R"(
 Variants:
 - Dir: thumb/v6-m/nofp
   Flags: [--target=thumbv6m-none-unknown-eabi, -mfpu=none]
 
- Match: -target=thumbv8\.[1-9]m\.main-none-unknown-eabi
   Flags: [--target=thumbv8.1m.main-none-unknown-eabi]
 - Match: -target=thumbv8\.[1-9]m\.main-none-unknown-eabihf
   Flags: [--target=thumbv8.1m.main-none-unknown-eabihf]
 - Match: -march=thumbv8\.[1-9]m\.main.*\+mve($|\+).*
   Flags: [-march=thumbv8.1m.main+mve]
 )";
 
   MultilibSet MS;
-  Multilib Selected;
+  llvm::SmallVector<Multilib> Selected;
   ASSERT_TRUE(parseYaml(MS, MultilibSpec));
 
   ASSERT_TRUE(MS.select({"--target=thumbv6m-none-unknown-eabi", "-mfpu=none"},
                         Selected));
-  EXPECT_EQ("/thumb/v6-m/nofp", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v6-m/nofp", Selected.back().gccSuffix());
 
   ASSERT_TRUE(MS.select({"--target=thumbv7m-none-unknown-eabi", "-mfpu=none"},
                         Selected));
-  EXPECT_EQ("/thumb/v7-m/nofp", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v7-m/nofp", Selected.back().gccSuffix());
 
   ASSERT_TRUE(MS.select({"--target=thumbv7em-none-unknown-eabi", "-mfpu=none"},
                         Selected));
-  EXPECT_EQ("/thumb/v7e-m/nofp", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v7e-m/nofp", Selected.back().gccSuffix());
 
   ASSERT_TRUE(MS.select(
       {"--target=thumbv8m.main-none-unknown-eabi", "-mfpu=none"}, Selected));
-  EXPECT_EQ("/thumb/v8-m.main/nofp", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v8-m.main/nofp", Selected.back().gccSuffix());
 
   ASSERT_TRUE(MS.select(
       {"--target=thumbv8.1m.main-none-unknown-eabi", "-mfpu=none"}, Selected));
-  EXPECT_EQ("/thumb/v8.1-m.main/nofp/nomve", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v8.1-m.main/nofp/nomve", Selected.back().gccSuffix());
 
   ASSERT_TRUE(
       MS.select({"--target=thumbv7em-none-unknown-eabihf", "-mfpu=fpv4-sp-d16"},
                 Selected));
-  EXPECT_EQ("/thumb/v7e-m/fpv4_sp_d16", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v7e-m/fpv4_sp_d16", Selected.back().gccSuffix());
 
   ASSERT_TRUE(MS.select(
       {"--target=thumbv7em-none-unknown-eabihf", "-mfpu=fpv5-d16"}, Selected));
-  EXPECT_EQ("/thumb/v7e-m/fpv5_d16", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v7e-m/fpv5_d16", Selected.back().gccSuffix());
 
   ASSERT_TRUE(
       MS.select({"--target=thumbv8m.main-none-unknown-eabihf"}, Selected));
-  EXPECT_EQ("/thumb/v8-m.main/fp", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v8-m.main/fp", Selected.back().gccSuffix());
 
   ASSERT_TRUE(
       MS.select({"--target=thumbv8.1m.main-none-unknown-eabihf"}, Selected));
-  EXPECT_EQ("/thumb/v8.1-m.main/fp", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v8.1-m.main/fp", Selected.back().gccSuffix());
 
   ASSERT_TRUE(MS.select({"--target=thumbv8.1m.main-none-unknown-eabihf",
                          "-mfpu=none", "-march=thumbv8.1m.main+dsp+mve"},
                         Selected));
-  EXPECT_EQ("/thumb/v8.1-m.main/nofp/mve", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v8.1-m.main/nofp/mve", Selected.back().gccSuffix());
 }