[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

224

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

319

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::tag_set &Tags) const;
-
-  /// Pick the best multilib in the set, \returns false if none are compatible
-  bool select(const Multilib::tag_set &Tags, Multilib &M) const;
+  /// Select compatible variants, \returns false if none are compatible
+  bool select(const Multilib::tag_set &Tags,
+              llvm::SmallVector<Multilib> &) const;
 
   unsigned size() const { return Multilibs.size(); }
 
   /// Get the given tags plus tags found by matching them against the
   /// TagMatchers and choosing the MatchTags or NoMatchTags of each
   /// accordingly. The select method calls this method so in most cases it's not
   /// necessary to call it directly.
   Multilib::tag_set expandTags(const Multilib::tag_set &) 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 tags 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 but different:
   /// * It's 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_selection_tags)) {
     auto AllTags = TC.getMultilibs().expandTags(
         Multilib::tag_set(ArgTags.begin(), ArgTags.end()));
     for (StringRef Tag : AllTags)
       llvm::outs() << Tag << '\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); }
 
-std::vector<Multilib> MultilibSet::select(const Multilib::tag_set &Tags) const {
+bool MultilibSet::select(const Multilib::tag_set &Tags,
+                         llvm::SmallVector<Multilib> &Selected) const {
   Multilib::tag_set AllTags(expandTags(Tags));
-  multilib_list Result;
-  llvm::copy_if(Multilibs, std::back_inserter(Result),
+  Selected.clear();
+  llvm::copy_if(Multilibs, std::back_inserter(Selected),
                 [&AllTags](const Multilib &M) {
                   return std::includes(AllTags.begin(), AllTags.end(),
                                        M.tags().begin(), M.tags().end());
                 });
-  return Result;
-}
-
-bool MultilibSet::select(const Multilib::tag_set &Tags,
-                         Multilib &Selected) const {
-  multilib_list Result = select(Tags);
-  if (Result.empty())
-    return false;
-  Selected = Result.back();
-  return true;
+  return !Selected.empty();
 }
 
 Multilib::tag_set
 MultilibSet::expandTags(const Multilib::tag_set &InTags) const {
   Multilib::tag_set Result(InTags);
   for (const TagMatcher &M : TagMatchers) {
     std::string RegexString(M.Regex);
 

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,
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MB =
       D.getVFS().getBufferForFile(MultilibPath);
   if (!MB)
     return false;
   std::vector<std::string> ArgsTags = TC.getMultiSelectionTags(Args);
   if (!Result.Multilibs.parse(*MB.get()))
     return false;
   Multilib::tag_set Tags(ArgsTags.begin(), ArgsTags.end());
-  return Result.Multilibs.select(Tags, Result.SelectedMultilib);
+  return Result.Multilibs.select(Tags, Result.SelectedMultilibs);
 }
 
 #define MULTILIB_YAML_FILENAME "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, MULTILIB_YAML_FILENAME);
     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::tag_set &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::tag_set &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::tag_set &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::tag_set &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::tag_set 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::tag_set 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/RISCVToolchain.cpp

 
 /// RISCV 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::tag_set 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::tag_set 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::tag_set Flags;
     if (IsEL)
       Flags.insert("+EL");
     else
       Flags.insert("-EL");
 
     if (IsSF)
       Flags.insert("+SF");
     else
       Flags.insert("-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 ";
   }
 }
 
 TEST(MultilibBuilderTest, PrintOptions) {
   Multilib M = MultilibBuilder()
                    .flag("+x")
                    .flag("-y")
                    .flag("+a")
                    .flag("-b")
                    .flag("+c")
                    .makeMultilib();
   ASSERT_EQ(Multilib::option_list({"-x", "-a", "-c"}), M.getPrintOptions());
 }

clang/unittests/Driver/MultilibTest.cpp

 }
 
 TEST(MultilibTest, SetPriority) {
   MultilibSet MS({
       Multilib("/foo", {}, {}, {"+foo"}),
       Multilib("/bar", {}, {}, {"+bar"}),
   });
   Multilib::tag_set Tags1 = {"+foo", "-bar"};
-  Multilib Selection1;
+  llvm::SmallVector<Multilib> Selection1;
   ASSERT_TRUE(MS.select(Tags1, Selection1))
       << "Tag 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::tag_set Tags2 = {"+foo", "+bar"};
-  Multilib Selection2;
+  llvm::SmallVector<Multilib> Selection2;
   ASSERT_TRUE(MS.select(Tags2, Selection2))
       << "Tag 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
   Tags: []
   PrintOptions: []
 )"));
   EXPECT_EQ(2U, MS.size());
 }
 
 TEST(MultilibTest, SelectSoft) {
   MultilibSet MS;
-  Multilib Selected;
+  llvm::SmallVector<Multilib> Selected;
   ASSERT_TRUE(parse(MS, YAML_PREAMBLE R"(
 Variants:
 - Dir: s
   Tags: [softabi]
   PrintOptions: []
 TagMap:
 - Regex: mfloat-abi=soft
   MatchTags: [softabi]
 - Regex: mfloat-abi=softfp
   MatchTags: [softabi]
 )"));
   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(parse(MS, YAML_PREAMBLE R"(
 Variants:
 - Dir: f
   Tags: [mfloat-abi=softfp]
   PrintOptions: []
 )"));
   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(parse(MS, YAML_PREAMBLE R"(
 Variants:
 - Dir: h
   Tags: [mfloat-abi=hard]
   PrintOptions: []
 )"));
   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(parse(MS, YAML_PREAMBLE R"(
 Variants:
 - Dir: s
   Tags: [softabi]
   PrintOptions: []
 - Dir: f
   Tags: [softabi, hasfp]
   PrintOptions: []
 - Dir: h
   Tags: [hardabi, hasfp]
   PrintOptions: []
 TagMap:
 - Regex: mfloat-abi=(soft|softfp)
   MatchTags: [softabi]
 - Regex: mfloat-abi=hard
   MatchTags: [hardabi]
 - Regex: mfloat-abi=soft
   NoMatchTags: [hasfp]
 )"));
   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(parse(MS, YAML_PREAMBLE R"(
 Variants:
 - Dir: h
   Tags: [hardabi, hasfp]
   PrintOptions: []
 - Dir: f
   Tags: [softabi, hasfp]
   PrintOptions: []
 - Dir: s
   Tags: [softabi]
   PrintOptions: []
 TagMap:
 - Regex: mfloat-abi=(soft|softfp)
   MatchTags: [softabi]
 - Regex: mfloat-abi=hard
   MatchTags: [hardabi]
 - Regex: mfloat-abi=soft
   NoMatchTags: [hasfp]
 )"));
   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
   Tags: [target=thumbv6m-none-eabi]
   PrintOptions: [--target=thumbv6m-none-eabi, -mfloat-abi=soft]
- Regex: target=thumbv8(\.[0-9]+)?m\.base-none-eabi
   MatchTags: [target=thumbv6m-none-eabi]
 - Regex: thumbv8\.[1-9]m\.main-none-eabi
   MatchTags: [target=thumbv8.1m.main-none-eabi]
 - Regex: thumbv8\.[1-9]m\.main-none-eabihf
   MatchTags: [target=thumbv8.1m.main-none-eabihf]
 )";
 
   MultilibSet MS;
-  Multilib Selected;
+  llvm::SmallVector<Multilib> Selected;
   ASSERT_TRUE(parse(MS, MultilibSpec));
 
   EXPECT_TRUE(
       MS.select({"target=thumbv6m-none-eabi", "mfloat-abi=soft"}, Selected));
-  EXPECT_EQ("/thumb/v6-m/nofp", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v6-m/nofp", Selected.back().gccSuffix());
 
   EXPECT_TRUE(
       MS.select({"target=thumbv7m-none-eabi", "mfloat-abi=soft"}, Selected));
-  EXPECT_EQ("/thumb/v7-m/nofp", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v7-m/nofp", Selected.back().gccSuffix());
 
   EXPECT_TRUE(
       MS.select({"target=thumbv7em-none-eabi", "mfloat-abi=soft", "mfpu=none"},
                 Selected));
-  EXPECT_EQ("/thumb/v7e-m/nofp", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v7e-m/nofp", Selected.back().gccSuffix());
 
   EXPECT_TRUE(MS.select({"target=thumbv8m.main-none-eabi", "mfloat-abi=soft"},
                         Selected));
-  EXPECT_EQ("/thumb/v8-m.main/nofp", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v8-m.main/nofp", Selected.back().gccSuffix());
 
   EXPECT_TRUE(MS.select(
       {"target=thumbv8.1m.main-none-eabi", "mfloat-abi=soft", "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());
 
   EXPECT_TRUE(MS.select(
       {"target=thumbv7em-none-eabihf", "mfloat-abi=hard", "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());
 
   EXPECT_TRUE(MS.select(
       {"target=thumbv7em-none-eabihf", "mfloat-abi=hard", "mfpu=fpv5-d16"},
       Selected));
-  EXPECT_EQ("/thumb/v7e-m/fpv5_d16", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v7e-m/fpv5_d16", Selected.back().gccSuffix());
 
   EXPECT_TRUE(MS.select({"target=thumbv8m.main-none-eabihf", "mfloat-abi=hard"},
                         Selected));
-  EXPECT_EQ("/thumb/v8-m.main/fp", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v8-m.main/fp", Selected.back().gccSuffix());
 
   EXPECT_TRUE(MS.select(
       {"target=thumbv8.1m.main-none-eabihf", "mfloat-abi=hard"}, Selected));
-  EXPECT_EQ("/thumb/v8.1-m.main/fp", Selected.gccSuffix());
+  EXPECT_EQ("/thumb/v8.1-m.main/fp", Selected.back().gccSuffix());
 
   EXPECT_TRUE(MS.select({"target=thumbv8.1m.main-none-eabihf",
                          "mfloat-abi=hard", "mfpu=none", "march=+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());
 }