RFC: Multilib prototype

[michaelplatings]

Summary

This is a prototype of a new approach to multilib.

The multilib.yaml file is a new interface that allows customising (a) which system library variants are available; and (b) how a library variant is identified as compatible with the clang arguments provided by the user.

The file clang/test/Driver/Inputs/baremetal_multilib/arm-none-eabi/multilib.yaml is an example that contains comments explaining how it is used.

The project I'm working on is LLVM Embedded Toolchain for Arm so the design is made with that in mind, but it's intended to be flexible enough to work with other toolchains with many system library variants.

RFC thread is here: https://discourse.llvm.org/t/rfc-multilib/67494

[phosek]

clang/include/clang/Driver/Multilib2.h

33–34

I think it'd really help readability and comprehension if this was modeled using types (that is structs and classes). It's not at all clear what these strings are supposed to represent, and seeing expressions like std::get<0> doesn't help either.

clang/test/Driver/Inputs/baremetal_multilib/arm-none-eabi/multilib.yaml

24

I understand how the second section is used to match arguments passed to clang -cc1 and turn those into attributes which are then used to find the right variant, but I don't understand what this list of arguments is used for?

[michaelplatings]

clang/include/clang/Driver/Multilib2.h

33–34

I fully agree. Sorry if I wasn't clear in the RFC but this is the kind of thing I meant when I said the code is not intended to be production quality.

clang/test/Driver/Inputs/baremetal_multilib/arm-none-eabi/multilib.yaml

24

Having these here permits clang -print-multi-lib to work, which would print out something like this:

thumb/nofp;@mthumb@mfloat-abi=soft
thumb/v7/nofp;@mthumb@march=armv7@mfloat-abi=soft
...

[tschuett]

Did you look at Yaml I/O?

[simon_tatham]

"Make difficult things possible": perhaps it might be useful to make sure it's at least possible to express a complex boolean function of the basic predicates, even if it's cumbersome? (So that, for example, you could make an attribute conditional on "this cc1 option but not that one".) I assume YAML would let you write something like an expression AST in hierarchical form, with predicates like regex: at the leaves, and internal nodes for AND, OR and NOT.

Then again, perhaps it's enough to just make sure there's extension room in the syntax so that this can be added later, and there's no need to actually implement it in the first version.

clang/test/Driver/Inputs/baremetal_multilib/arm-none-eabi/multilib.yaml

75

Nit: don't forget to document whether these use basic or extended regex syntax

[michaelplatings]

A constraint is that the user should be able to choose the library with a single list of arguments, as displayed with -print-multi-lib. Therefore I'm sceptical about making the selection mechanism too expressive, because -print-multi-lib can't explain that to the user. Already the presence of negation is stretching that.

Nevertheless let's pick an example of something that can't be directly expressed in the prototype: NOT (a AND b). (I don't know why you'd want to do that, if you have a motivating example of something genuinely useful then that would be better)

The expression can be rearranged to (a AND NOT b) OR (b AND NOT a) OR ((NOT a) AND NOT b) which can be represented in an ugly way:

variants:
- path: p
  args: [-a]
  attrs: [a, not-b]
- path: p
  args: [-b]
  attrs: [not-a, b]
- path: p
  args: []
  attrs: [not-a, not-b]
arguments:
- regex: -a
  matchAttrs: [a]
  noMatchAttrs: [not-a]
- regex: -b
  matchAttrs: [b]
  noMatchAttrs: [not-b]

I think this fits with the spirit of "Make the easy things easy, and the hard things possible."

perhaps it's enough to just make sure there's extension room in the syntax so that this can be added later

One of the many nice things about JSON & YAML is it gives you loads of room for extension, so yes. For example, currently attrs must be an array, but the option could be added later that it could be an object like attrs: {not: [a, b]}. But I hope it doesn't prove necessary ;)

[lenary]

Thanks for putting together this proposal.

Broadly, I think it's good, and I think it solves a lot of rough edges that I recall running into with the GCC multilib configuration files in the past.

I do worry about using -cc1 args. On the one hand, it's the best place for getting access to information about e.g. exceptions, floating point abi, and other concepts (optimisation level?), but on the other hand, it is a reasonably unstable interface, and it's parsed in a complex and stateful way -- later options can override earlier ones -- which makes it difficult to parse with regular expressions.

To be clear: I don't think there's a better way of handling exceptions/no-exceptions library selection (than parsing the -cc1 arguments) or the floating point abi library selection, so having a way to examining the -cc1 arguments is a necessary "lowest common denominator" interface (I'll come back to this later), but I think there are places we can do better.

In terms of finding a more stable interface, the Arm ACLE recently added Beta support for Function Multi-Versioning which is proposing a lot of stable identifiers for architectural features in v8-a and v8-r onwards. These names are expected to be written by programmers in their source code, so are a stable interface in a way that -target-feature +<name> is absolutely not. These are resolved by clang in order to handle duplicating the same function to compile it for multiple targets, which to my mind is the exact same problem that multi-libs are trying to solve. We have specified stable names for a lot of features in the ACLE (and presumably will continue to do so), as well as a priority system for resolving how to choose which function should be used at runtime. I concede that these stable names do not cover M-profile or pre-v8 architectures, which are important to embedded toolchains.

The information about these stable feature names is known about by AArch64TargetInfo right now, and we are looking at where exactly this information should be best understood by LLVM in general (maybe the TargetParser library). Given where it is in clang's code, I think it should be usable by both the driver and internally inside -cc1, but I'm not 100% sure the C++ interface is perfect for both. But, we can always revisit the C++ interface to make it work for what we want.

So, to concretely turn this into a proposal, I think there are two things you could do:

• in the arguments: part of the yaml structure, you currently have regex: which is for matching on the -cc1 arguments, we could have a archFeatures: for matching on a list/set of named features (instead of the regex:), to turn them into multilib library attributes.
• treat the stable architectural feature names like extra implicit attributes that don't show up in the arguments: section, but can be used in the variants: section like the -cc1-derived attributes. Here, we would need to be careful the architectural feature names didn't clash with the user-provided names from the arguments: section, and we might need to have a way to specify the absence of architectural features as well. I'm not 100% convinced that the implicit-ness of this option is good, but I think the stability wins are useful.

To cover some drawbacks of the approach of using these stable names:

• Not all targets support function multi-versioning. In this case, they are welcome to fall back to using -cc1 arguments, as a lowest common denominator approach.
• Not all multilibs are chosen based on architectural features: again, you can fall-back to -cc1 arguments, especially as I think e.g. -fno-exceptions is more stable than -target-feature +<name>.
• Even for Arm/AArch64, there are pre-v8-a/v8-r architectures which don't have stable names in the ACLE yet. Again, in the short term we could use -cc1 arguments, before we stabilise architectural names.

[michaelplatings]

How the multilib system matches user arguments is the main problem I've been struggling with.

These are the options I see:

1. Grant the multilib system full access to all cc1 arguments, as demonstrated by the current code. However declare the multilib system unstable - if you write a multilib specification, you are responsible for making sure it's updated when clang is updated. Clang plugins set the precedent for such an approach.
   
   Advantage: It's powerful.
   
   Disadvantages:
   • Experience with clang plugins suggests instability will be a source of frequent pain.
   • @lenary points out that the order of arguments can be significant.
   • Requires some major refactoring of how arguments are processed before this can be done in a robust way (how I implemented it in the prototype is far from robust).

2. Pass to the multilib system only the arguments as provided by the user.
   
   Advantage: Greatly reduced API surface.
   
   Disadvantage: whoever writes a multilib specification will have to reinvent a lot of logic to infer attributes from --target, -march, -mcpu etc. but with inadequate tools to do so.

3. Normalise user arguments before passing them to the multilib system.
   
   Advantages:
   • Uses the existing arguments API.
   • Powerful, if it can be done correctly.
     
     Disadvantage:
   • The normalisation process effectively becomes a new API.
   • Normalisation appears hard to do correctly = likelihood of bugs.
   • Identifying attributes from arguments is fiddly e.g. extracting Arm architecture extensions from the march argument.
   • It's too easy to write a regex that could unintentionally match a newly introduced argument so the instability problem remains somewhat.

4. Hard-code the attributes and how they are detected in the same way they already are right now. For Arm this could be extended with Function Multi Versioning as @lenary pointed to, with namespacing to avoid potential clashes with other names. So you could have attributes like [fsanitize=address, fno-exceptions, mfloat-abi=softfp, march=thumbv8.1m.main, arm:mve].
   
   Advantages:
   • This is similar to what we already do for multilib so it's well understood.
   • Limited yet extensible API.
     
     Disadvantages:
   • Greatly limits the expressiveness of the multilib system.
   • Any time someone wants to base their multilib on a new attribute it requires a change to Clang.
   • Some regular expressions still required for forward compatibility e.g. with future versions of Armv8-M.

5. A combination of (1) and (4) as proposed by @lenary.
   
   Advantages:
   • Stability where predefined attributes are available.
   • The power to access unstable arguments if necessary.
     
     Disadvantages:
   • Same as for (1) - requires some major refactoring of how arguments are processed before this can be done in a robust way (how I implemented it in the prototype is far from robust).
   • Greater maintenance burden.

None of these options are great but (4) is low risk and extensible so I'm currently investigating that.

[Joe]

FWIW I tried this patch out with RISC-V multilibs, and it works a treat. It solves the multilib reuse problem and relaxes the order of non-standard extensions. I did have to copy some of the logic from BareMetal.cpp to Gnu.cpp as was using a GCC installation.

The args field for the YAML was unnecessary and worked (including --print-multi-lib) just fine without it.

[michaelplatings]

I've created a new stack of changes taking into account the feedback. Unlike this change which was strictly a prototype, the new changes should be suitable for detailed review and hopefully approval.

• https://reviews.llvm.org/D142878 - Add testing for Fuchsia multilib
• https://reviews.llvm.org/D142893 - Class for building MultilibSet
• https://reviews.llvm.org/D142905 - Change multilib selection algorithm
• https://reviews.llvm.org/D142932 - Multilib YAML parsing
• https://reviews.llvm.org/D142933 - Add -print-multi-selection-flags argument
• https://reviews.llvm.org/D142986 - Enable multilib.yaml in the BareMetal ToolChain

I'm working on further patches to enable multilib layering, but that needn't block the above changes.

Thanks for giving it a try @Joe. The new changes are by design much more limited, in order to avoid creating an unstable API. I'd be interested to learn from you whether it's suitable for what you need, possibly by adding more functionality. In particular you'll see that https://reviews.llvm.org/D142933 has functionality specific to Arm extensions so something similar may be required for other architectures.

In D140959#4028638, @tschuett wrote:

Did you look at Yaml I/O?

Thanks for the tip, I've used it in https://reviews.llvm.org/D142932 and it's a great improvement.

clang/include/clang/Driver/Multilib2.h

+//===- Multilib2.h ----------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_DRIVER_MULTILIB2_H
+#define LLVM_CLANG_DRIVER_MULTILIB2_H
+
+#include "clang/Basic/LLVM.h"
+#include <string>
+
+namespace clang {
+namespace driver {
+
+class Multilib2 {
+public:
+  using const_iterator = std::vector<std::tuple<std::string, std::vector<std::string>, std::vector<std::string>>>::const_iterator;
+
+  Multilib2();
+
+  size_t size() const { return Multilibs.size(); }
+  const_iterator begin() const { return Multilibs.begin(); }
+  const_iterator end() const { return Multilibs.end(); }
+
+  bool parse(StringRef, raw_ostream &Err);
+
+  std::pair<bool, std::string> select(ArrayRef<const char *> Arguments) const;
+
+private:
+  std::vector<std::tuple<std::string, std::vector<std::string>, std::vector<std::string>>> Multilibs;
+  std::vector<std::tuple<std::string, std::vector<std::string>, std::vector<std::string>>> RegexAttributes;
+};
+
+} // namespace driver
+} // namespace clang
+
+#endif // LLVM_CLANG_DRIVER_MULTILIB2_H

clang/lib/Driver/CMakeLists.txt

 add_clang_library(clangDriver
   Action.cpp
   Compilation.cpp
   Distro.cpp
   Driver.cpp
   DriverOptions.cpp
   Job.cpp
   Multilib.cpp
+  Multilib2.cpp
   OffloadBundler.cpp
   OptionUtils.cpp
   Phases.cpp
   SanitizerArgs.cpp
   Tool.cpp
   ToolChain.cpp
   ToolChains/Arch/AArch64.cpp
   ToolChains/Arch/ARM.cpp

clang/lib/Driver/Multilib2.cpp

+//===- Multilib2.cpp - Multilib2 Implementation -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "ToolChains/BareMetal.h"
+#include "ToolChains/Clang.h"
+#include "clang/Driver/Multilib2.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cassert>
+#include <regex>
+#include <set>
+#include <vector>
+
+#include "clang/Driver/Compilation.h"
+#include "clang/Driver/Driver.h"
+#include "clang/Driver/DriverDiagnostic.h"
+#include "clang/Driver/Options.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/VirtualFileSystem.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/YAMLParser.h"
+#include "llvm/TargetParser/Host.h"
+
+using namespace clang;
+using namespace driver;
+
+Multilib2::Multilib2() {}
+
+bool Multilib2::parse(StringRef Input, raw_ostream &Err) {
+  std::vector<std::tuple<std::string, std::vector<std::string>, std::vector<std::string>>> MultilibList;
+  std::vector<std::tuple<std::string, std::vector<std::string>, std::vector<std::string>>> RegexAttributesList;
+
+
+  llvm::SourceMgr SM;
+  llvm::yaml::Stream Stream(Input, SM);
+  llvm::yaml::document_iterator DocumentIterator = Stream.begin();
+
+  // There has to be at least one document available.
+  if (DocumentIterator == Stream.end())
+    return false;
+
+  llvm::yaml::Node *DocumentRoot = DocumentIterator->getRoot();
+  if (!DocumentRoot) {
+    // TODO report error
+    return false;
+  }
+
+  auto *TopMappings = dyn_cast<llvm::yaml::MappingNode>(DocumentRoot);
+  if (!TopMappings) {
+    // TODO report error
+    return false;
+  }
+
+  for (auto &TopMapping : *TopMappings) {
+    // The keys should be strings, which represent a source-file path.
+    auto *TopKey = dyn_cast<llvm::yaml::ScalarNode>(TopMapping.getKey());
+    if (!TopKey) {
+      // TODO report error
+      return false;
+    }
+
+    if (TopKey->getRawValue() == "variants") {
+      auto Variants = dyn_cast<llvm::yaml::SequenceNode>(TopMapping.getValue());
+      if (!Variants) {
+        // TODO report error
+        return false;
+      }
+      for (auto &Variant : *Variants) {
+        std::string Path;
+        std::vector<std::string> Args, Attrs;
+
+        llvm::yaml::MappingNode *VariantMappings = dyn_cast<llvm::yaml::MappingNode>(&Variant);
+        if (!VariantMappings) {
+          // TODO report error
+          return false;
+        }
+        for (auto &VariantMapping : *VariantMappings) {
+          auto *VariantKey = dyn_cast<llvm::yaml::ScalarNode>(VariantMapping.getKey());
+          if (!VariantKey) {
+            // TODO report error
+            return false;
+          }
+          if (VariantKey->getRawValue() == "path") {
+            auto *VariantValue = dyn_cast<llvm::yaml::ScalarNode>(VariantMapping.getValue());
+            if (!VariantValue) {
+              // TODO report error
+              return false;
+            }
+            SmallString<32> PathStorage;
+            Path = VariantValue->getValue(PathStorage).str();
+          }
+          if (VariantKey->getRawValue() == "args") {
+            auto Arguments = dyn_cast<llvm::yaml::SequenceNode>(VariantMapping.getValue());
+            if (!Arguments) {
+              // TODO report error
+              return false;
+            }
+            for (auto &Argument : *Arguments) {
+              auto *ArgumentValue = dyn_cast<llvm::yaml::ScalarNode>(&Argument);
+              if (!ArgumentValue) {
+                // TODO report error
+                return false;
+              }
+              SmallString<32> ArgumentStorage;
+              Args.push_back(ArgumentValue->getValue(ArgumentStorage).str());
+            }
+          }
+          if (VariantKey->getRawValue() == "attrs") {
+            auto Attributes = dyn_cast<llvm::yaml::SequenceNode>(VariantMapping.getValue());
+            if (!Attributes) {
+              // TODO report error
+              return false;
+            }
+            for (auto &Attribute : *Attributes) {
+              auto *AttributeValue = dyn_cast<llvm::yaml::ScalarNode>(&Attribute);
+              if (!AttributeValue) {
+                // TODO report error
+                return false;
+              }
+              SmallString<32> AttributeStorage;
+              Attrs.push_back(AttributeValue->getValue(AttributeStorage).str());
+            }
+          }
+        }
+        if (StringRef(Path).starts_with("/")) {
+          Err << "paths must be relative. \"" << Path << "\" starts with \"/\"\n";
+          return false;
+        }
+        if (Path == ".") {
+          Path = "";
+        } else {
+          Path = "/" + Path;
+        }
+        // TODO: add test that breaks if no sorting is done.
+        std::sort(Attrs.begin(), Attrs.end());
+        MultilibList.push_back(std::tuple<std::string, std::vector<std::string>, std::vector<std::string>>(Path, Args, Attrs));
+      }
+    } else if (TopKey->getRawValue() == "arguments") {
+      auto Arguments = dyn_cast<llvm::yaml::SequenceNode>(TopMapping.getValue());
+      if (!Arguments) {
+        // TODO report error
+        return false;
+      }
+      for (auto &Argument : *Arguments) {
+        std::string Regex;
+        std::vector<std::string> MatchAttrs, NoMatchAttrs;
+
+        llvm::yaml::MappingNode *ArgumentMappings = dyn_cast<llvm::yaml::MappingNode>(&Argument);
+        if (!ArgumentMappings) {
+          // TODO report error
+          return false;
+        }
+        for (auto &ArgumentMapping : *ArgumentMappings) {
+          auto *ArgumentKey = dyn_cast<llvm::yaml::ScalarNode>(ArgumentMapping.getKey());
+          if (!ArgumentKey) {
+            // TODO report error
+            return false;
+          }
+          if (ArgumentKey->getRawValue() == "regex") {
+            auto *ArgumentValue = dyn_cast<llvm::yaml::ScalarNode>(ArgumentMapping.getValue());
+            if (!ArgumentValue) {
+              // TODO report error
+              return false;
+            }
+            SmallString<32> PathStorage;
+            Regex = ArgumentValue->getValue(PathStorage).str();
+          }
+          if (ArgumentKey->getRawValue() == "matchAttrs") {
+            auto Arguments = dyn_cast<llvm::yaml::SequenceNode>(ArgumentMapping.getValue());
+            if (!Arguments) {
+              // TODO report error
+              return false;
+            }
+            for (auto &Argument : *Arguments) {
+              auto *ArgumentValue = dyn_cast<llvm::yaml::ScalarNode>(&Argument);
+              if (!ArgumentValue) {
+                // TODO report error
+                return false;
+              }
+              SmallString<32> ArgumentStorage;
+              MatchAttrs.push_back(ArgumentValue->getValue(ArgumentStorage).str());
+            }
+          }
+          if (ArgumentKey->getRawValue() == "noMatchAttrs") {
+            auto Attributes = dyn_cast<llvm::yaml::SequenceNode>(ArgumentMapping.getValue());
+            if (!Attributes) {
+              // TODO report error
+              return false;
+            }
+            for (auto &Attribute : *Attributes) {
+              auto *AttributeValue = dyn_cast<llvm::yaml::ScalarNode>(&Attribute);
+              if (!AttributeValue) {
+                // TODO report error
+                return false;
+              }
+              SmallString<32> AttributeStorage;
+              NoMatchAttrs.push_back(AttributeValue->getValue(AttributeStorage).str());
+            }
+          }
+        }
+        RegexAttributesList.push_back(std::tuple<std::string, std::vector<std::string>, std::vector<std::string>>(Regex, MatchAttrs, NoMatchAttrs));
+      }
+    }
+  }
+
+  Multilibs.swap(MultilibList);
+  RegexAttributes.swap(RegexAttributesList);
+
+  return true;
+}
+
+static std::vector<std::string> normalizeArgs(ArrayRef<const char *> ArgsWithoutFile) {
+  const char *ExecutableName = "/no/such/clang";
+  const char *TestFileName = "test.c";
+  std::vector<const char *> Args = {ExecutableName, TestFileName};
+  for (const char *A : ArgsWithoutFile) {
+    if (A != StringRef("-###")) {
+      Args.push_back(A);
+    }
+  }
+  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  struct TestDiagnosticConsumer : public DiagnosticConsumer {};
+  IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
+      new llvm::vfs::InMemoryFileSystem);
+  InMemoryFileSystem->addFile(TestFileName, time_t(), llvm::MemoryBuffer::getMemBuffer(""));
+  DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
+  Driver D(ExecutableName, llvm::sys::getDefaultTargetTriple(), Diags, "clang LLVM compiler", InMemoryFileSystem);
+  std::unique_ptr<Compilation> C(D.BuildCompilation(Args));
+  if (C->getJobs().empty()) {
+    return std::vector<std::string>();
+  }
+  llvm::opt::ArgStringList NormalisedArgStrings = C->getJobs().begin()->getArguments();
+
+  unsigned MissingArgIndex = 0, MissingArgCount = 0;
+  llvm::opt::InputArgList ParsedArgs = getDriverOptTable().ParseArgs(NormalisedArgStrings, MissingArgIndex, MissingArgCount);
+
+  std::vector<std::string> Result;
+  for (const llvm::opt::Arg *A : ParsedArgs) {
+    Result.push_back(A->getAsString(ParsedArgs));
+  }
+  return Result;
+}
+
+static std::vector<std::string> argsToAttributes(ArrayRef<std::string> Arguments, const std::vector<std::tuple<std::string, std::vector<std::string>, std::vector<std::string>>> &RegexAttributesList) {
+  std::set<std::string> Result;
+  for (const std::tuple<std::string, std::vector<std::string>, std::vector<std::string>> &RegexAttributes : RegexAttributesList) {
+    const std::regex Regex(std::get<0>(RegexAttributes));
+    const std::vector<std::string> &MatchAttrs = std::get<1>(RegexAttributes);
+    const std::vector<std::string> &NoMatchAttrs = std::get<2>(RegexAttributes);
+    bool Match = false;
+    for (const std::string &Argument : Arguments) {
+      if (std::regex_match(Argument, Regex)) {
+        Match = true;
+        break;
+      }
+    }
+    if (Match) {
+      Result.insert(MatchAttrs.begin(), MatchAttrs.end());
+    } else {
+      Result.insert(NoMatchAttrs.begin(), NoMatchAttrs.end());
+    }
+  }
+  return std::vector<std::string>(Result.begin(), Result.end());
+}
+
+std::pair<bool, std::string> Multilib2::select(ArrayRef<const char *> Arguments) const {
+  std::pair<bool, std::string> Result(false, "");
+  std::vector<std::string> NormalizedArguments(normalizeArgs(Arguments));
+  if (NormalizedArguments.empty()) {
+    return std::pair<bool, std::string>(false, "");
+  }
+  std::vector<std::string> Attrs = argsToAttributes(NormalizedArguments, RegexAttributes);
+  for (const std::tuple<std::string, std::vector<std::string>, std::vector<std::string>> &M : Multilibs) {
+    const std::vector<std::string> &MAttrs = std::get<2>(M);
+    if (std::includes(Attrs.begin(), Attrs.end(), MAttrs.begin(), MAttrs.end())) {
+      Result = std::pair<bool, std::string>(true, std::get<0>(M));
+    }
+  }
+  return Result;
+}

clang/lib/Driver/ToolChains/BareMetal.cpp

 #include "CommonArgs.h"
 #include "Gnu.h"
 #include "clang/Driver/InputInfo.h"
 
 #include "Arch/RISCV.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
+#include "clang/Driver/Multilib2.h"
 #include "clang/Driver/Options.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm::opt;
 using namespace clang;
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang::driver::toolchains;
 
+static std::string stringRemove(std::string S, StringRef Remove) {
+  for (;;) {
+    std::string::size_type i = S.find(Remove);
+    if (i == std::string::npos)
+      break;
+    S.erase(i, Remove.size());
+  }
+  return S;
+}
+
+/// To facilitate multilib, normalise the triple, discarding
+/// information that can be specified via other flags.
+static std::string simplifyTripleName(llvm::Triple Triple) {
+  Triple.setArchName(llvm::Triple::getArchTypePrefix(Triple.getArch()));
+
+  if (Triple.getEnvironment() == llvm::Triple::EABIHF) {
+    Triple.setEnvironment(llvm::Triple::EABI);
+  }
+
+  std::string Result = Triple.normalize();
+
+  return stringRemove(Result, "-unknown");
+}
+
+static std::string computeBaseSysRoot(const Driver &D, const llvm::Triple& Triple) {
+  if (!D.SysRoot.empty())
+    return D.SysRoot;
+
+  SmallString<128> SysRootDir(D.Dir);
+  llvm::sys::path::append(SysRootDir, "../lib/clang-runtimes");
+
+  // Try using the --target argument verbatim
+  SmallString<128> SysRootWithTarget(SysRootDir);
+  llvm::sys::path::append(SysRootWithTarget, D.getTargetTriple());
+  if (D.getVFS().exists(SysRootWithTarget)) {
+    return std::string(SysRootWithTarget);
+  }
+
+  SmallString<128> SysRootWithSimplifiedTarget(SysRootDir);
+  llvm::sys::path::append(SysRootWithSimplifiedTarget, simplifyTripleName(Triple));
+  if (D.getVFS().exists(SysRootWithSimplifiedTarget)) {
+    return std::string(SysRootWithSimplifiedTarget);
+  }
+
+  // Fall back to using the --target argument verbatim
+  return std::string(SysRootWithTarget);
+}
+
 static Multilib makeMultilib(StringRef commonSuffix) {
   return Multilib(commonSuffix, commonSuffix, commonSuffix);
 }
 
 static bool findRISCVMultilibs(const Driver &D,
                                const llvm::Triple &TargetTriple,
                                const ArgList &Args, DetectedMultilibs &Result) {
   Multilib::flags_list Flags;
if (TargetTriple.isRISCV32()) {
     addMultilibFlag(Abi == "ilp32f", "mabi=ilp32f", Flags);
 
     Result.Multilibs = MultilibSet().Either(I, Im, Iac, Imac, Imafc);
     return Result.Multilibs.select(Flags, Result.SelectedMultilib);
   }
   return false;
 }
 
+static std::string makeMultilibFilePath(const Driver &D, const llvm::Triple &TargetTriple) {
+  const std::string BaseSysRoot = computeBaseSysRoot(D, TargetTriple);
+  llvm::SmallString<128> Result(BaseSysRoot);
+  llvm::sys::path::append(Result, "multilib.yaml");
+  return std::string(Result);
+}
+
+static bool readMultilibFile(const Driver &D, const llvm::Twine &MultilibFileName, Multilib2 &Multilibs) {
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MB = D.getVFS().getBufferForFile(MultilibFileName);
+  return MB && Multilibs.parse(MB.get()->getBuffer(), llvm::errs());
+}
+
+/*
+Terms:
+* User sysroot: the sysroot specified by the user with --sysroot.
+* Base sysroot: the user sysroot, or a value chosen automatically according to
+  the target.
+* Final sysroot: if using multilib, a subdirectory of the base sysroot
+  containing include and lib directories; otherwise the same as the base
+  sysroot.
+* isysroot: Like sysroot, except for include directories.
+
+For each of lib (--sysroot) and include (-isysroot, falling back to --sysroot):
+1. Has the user specified a sysroot? If so, use that as the base sysroot
+   Else use try using the target verbatim as the base sysroot. Does it exist? If so, use it.
+   Else use the normalised, simplified target as the base sysroot.
+2. With the base sysroot chosen, multilib can be picked.
+   Does the base sysroot contain clang.multilib? If so, load it and use it.
+   Otherwise fall back to RISC-V's multilib implementation if appropriate,
+   otherwise no multilib.
+*/
+static bool findArmMultilibs(const Driver &D, const llvm::Triple &TargetTriple,
+                             const ArgList &Args,
+                             DetectedMultilibs &Result) {
+  Multilib2 M;
+
+  if (!readMultilibFile(D, makeMultilibFilePath(D, TargetTriple), M)) {
+    return false;
+  }
+
+  std::vector<std::string> ArgumentStrings;
+  for (const llvm::opt::Arg *A : Args) {
+    ArgumentStrings.push_back(A->getAsString(Args));
+  }
+
+  std::vector<const char *> ArgumentCStrings;
+  for (const std::string &S : ArgumentStrings) {
+    ArgumentCStrings.push_back(S.c_str());
+  }
+
+  std::pair<bool, std::string> SuccessAndPath = M.select(ArgumentCStrings);
+  StringRef Path = SuccessAndPath.second;
+  Result.SelectedMultilib = Multilib(Path, Path, Path);
+  return SuccessAndPath.first;
+}
+
 BareMetal::BareMetal(const Driver &D, const llvm::Triple &Triple,
                      const ArgList &Args)
     : ToolChain(D, Triple, Args) {
   getProgramPaths().push_back(getDriver().getInstalledDir());
   if (getDriver().getInstalledDir() != getDriver().Dir)
     getProgramPaths().push_back(getDriver().Dir);
 
   findMultilibs(D, Triple, Args);

 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;
       Multilibs = Result.Multilibs;
     }
+  } else if (isARMBareMetal(Triple) || isAArch64BareMetal(Triple)) {
+    if (findArmMultilibs(D, Triple, Args, Result)) {
+      SelectedMultilib = Result.SelectedMultilib;
+      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 {
-  if (!getDriver().SysRoot.empty())
-    return getDriver().SysRoot + SelectedMultilib.osSuffix();
-
-  SmallString<128> SysRootDir;
-  llvm::sys::path::append(SysRootDir, getDriver().Dir, "../lib/clang-runtimes",
-                          getDriver().getTargetTriple());
-
-  SysRootDir += SelectedMultilib.osSuffix();
-  return std::string(SysRootDir);
+  return computeBaseSysRoot(getDriver(), getTriple()) + SelectedMultilib.osSuffix();
 }
 
 void BareMetal::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
                                           ArgStringList &CC1Args) const {
   if (DriverArgs.hasArg(options::OPT_nostdinc))
     return;
 
   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {

clang/test/Driver/Inputs/baremetal_multilib/arm-none-eabi/multilib.yaml

+# This file is in two parts:
+# 1. A list of library variants.
+# 2. A mapping from command line arguments to attributes.
+
+# How does clang use this file?
+# 1. If the ToolChain class for the architecture supports this form of
+#    multilibit then it loads file if present in sysroot.
+# 2. Generate clang -cc1 arguments for the user provided arguments.
+# 3. Compare the arguments against each regular expression and store
+#    associated attributes if there's a match.
+# 4. Find the last library variant whose attributes are a subset of the
+#    attributes derived from the user provided arguments.
+# 5. Use the path for the library variant as the sysroot.
+
+# The first section of the file is the list of library variants.
+# A library is considered compatible if the attributes (see below)
+# derived from its arguments are a subset of the attributes derived
+# from the arguments provided by the user.
+# If multiple libraries are deemed compatible then the one that appears
+# last in the list wins.
+
+variants:
+- path: thumb/v6-m/nofp
+  args: [--target=arm-none-eabi, -mfloat-abi=soft, -march=armv6m]
+  attrs: [thumb, soft, v6m]
+- path: thumb/v7-m/nofp
+  args: [--target=arm-none-eabi, -mfloat-abi=soft, -march=armv7m+nofp]
+  attrs: [thumb, soft, v7m]
+- path: thumb/v7e-m/nofp
+  args: [--target=arm-none-eabi, -mfloat-abi=soft, -march=armv7em, -mfpu=none]
+  attrs: [thumb, soft, v7em]
+- path: thumb/v8-m.main/nofp
+  args: [--target=arm-none-eabi, -mfloat-abi=soft, -march=armv8m.main+nofp]
+  attrs: [thumb, soft, v8m.main]
+- path: thumb/v8.1-m.main/nofp/nomve
+  args: [--target=arm-none-eabi, -mfloat-abi=soft, -march=armv8.1m.main+nofp+nomve]
+  attrs: [thumb, soft, v8.1m.main]
+- path: thumb/v7e-m/fpv4_sp_d16
+  args: [--target=arm-none-eabi, -mfloat-abi=hard, -march=armv7em, -mfpu=fpv4-sp-d16]
+  attrs: [thumb, hard, v7em, vfp2sp]
+- path: thumb/v7e-m/fpv5_d16
+  args: [--target=arm-none-eabi, -mfloat-abi=hard, -march=armv7em, -mfpu=fpv5-d16]
+  attrs: [thumb, hard, v7em, fp-armv8d16sp]
+- path: thumb/v8-m.main/fp
+  args: [--target=arm-none-eabi, -mfloat-abi=hard, -march=armv8m.main+fp]
+  attrs: [thumb, hard, v8m.main]
+- path: thumb/v8.1-m.main/fp
+  args: [--target=arm-none-eabi, -mfloat-abi=hard, -march=armv8.1m.main+fp]
+  attrs: [thumb, hard, v8.1m.main, vfp2sp]
+- path: thumb/v8.1-m.main/nofp/mve
+  args: [--target=arm-none-eabi, -mfloat-abi=hard, -march=armv8.1m.main+nofp+mve]
+  attrs: [thumb, hard, v8.1m.main, mve]
+
+
+# The second section of the file is a map from clang -cc1 command line
+# options to attributes. These are the options printed out if you run
+# clang with "-###"
+# The regex must match a whole logical argument string
+# e.g. "-target-cpu generic" or "-msoft-float".
+# "matchAttrs" attributes will be added if an argument matches, while
+# "noMatchAttrs" attributes will be added otherwise.
+arguments:
+- regex: -triple aarch64.*
+  matchAttrs: [aarch64]
+- regex: -triple thumb.*
+  matchAttrs: [thumb]
+- regex: -mfloat-abi soft
+  matchAttrs: [soft]
+- regex: -mfloat-abi hard
+  matchAttrs: [hard]
+# Floating point registers are enabled by default.
+# If the feature isn't disabled then we know it's enabled.
+- regex: -target-feature -fpregs
+  noMatchAttrs: [fpregs]
+- regex: -target-feature \+vfp2sp
+  matchAttrs: [vfp2sp]
+# Used to distinguish "-march=armv7em -mfpu=fpv4-sp-d16" and
+# "-march=armv7em -mfpu=fpv5-d16"
+- regex: -target-feature \+fp-armv8d16sp
+  matchAttrs: [fp-armv8d16sp]
+- regex: -target-feature \+mve
+  matchAttrs: [mve]
+- regex: -triple .*v6m-.*
+  matchAttrs: [v6m]
+- regex: -triple .*v7m-.*
+  matchAttrs: [v7m, v6m]
+- regex: -triple .*v7em-.*
+  matchAttrs: [v7em, v7m, v6m]
+- regex: -triple .*v8m\.base-.*
+  matchAttrs: [v8m.base, v6m]
+- regex: -triple .*v8m\.main-.*
+  matchAttrs: [v8m.main, v7em, v7m, v6m]
+# Match v8.1m and later. We assume that v8.2m (if/when it exists) will
+# be backwards compatible with v8.1m.
+# The alternative is to not recognise later versions, and require that
+# this multilib spec is updated before it can be used with newer
+# architecture versions.
+- regex: -triple .*v8\.[0-9]+m\.base-.*
+  matchAttrs: [v8m.base, v6m]
+- regex: -triple .*v8\.[0-9]+m\.main-.*
+  matchAttrs: [v8.1m.main, v8m.main, v7em, v7m, v6m]

clang/test/Driver/arm-compiler-rt.c

 // RUN: %clang -target arm-none-eabi \
+// RUN:     --sysroot=%S/Inputs/resource_dir_with_arch_subdir \
 // RUN:     -resource-dir=%S/Inputs/resource_dir_with_arch_subdir \
 // RUN:     -rtlib=compiler-rt -### %s 2>&1 \
 // RUN:   | FileCheck %s -check-prefix ARM-EABI
 // ARM-EABI: "-L{{.*[/\\]}}Inputs/resource_dir_with_arch_subdir{{/|\\\\}}lib{{/|\\\\}}baremetal"
 // ARM-EABI: "-lclang_rt.builtins-arm"
 
 // RUN: %clang -target arm-linux-gnueabi \
 // RUN:     -resource-dir=%S/Inputs/resource_dir_with_arch_subdir \

clang/test/Driver/baremetal-multilib.cpp

+// REQUIRES: shell
+// UNSUPPORTED: system-windows
+
+// RUN: rm -rf %T/baremetal_multilib
+// RUN: mkdir -p %T/baremetal_multilib/bin
+// RUN: mkdir -p %T/baremetal_multilib/lib/clang-runtimes/arm-none-eabi/thumb/v8-m.main/fp/lib
+// RUN: touch %T/baremetal_multilib/lib/clang-runtimes/arm-none-eabi/thumb/v8-m.main/fp/lib/libclang_rt.builtins.a
+// RUN: ln -s %clang %T/baremetal_multilib/bin/clang
+// RUN: ln -s %S/Inputs/baremetal_multilib/arm-none-eabi/multilib.yaml %T/baremetal_multilib/lib/clang-runtimes/arm-none-eabi/multilib.yaml
+
+// RUN: %T/baremetal_multilib/bin/clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     --target=thumbv8m.main-none-eabihf --sysroot= \
+// RUN:   | FileCheck --check-prefix=CHECK-V6M-C %s
+// CHECK-V6M-C: "{{.*}}clang{{.*}}" "-cc1" "-triple" "thumbv8m.main-none-unknown-eabihf"
+// CHECK-V6M-C-SAME: "-internal-isystem" "{{.*}}/baremetal_multilib/bin/../lib/clang-runtimes/arm-none-eabi/thumb/v8-m.main/fp/include/c++/v1"
+// CHECK-V6M-C-SAME: "-internal-isystem" "{{.*}}/baremetal_multilib/bin/../lib/clang-runtimes/arm-none-eabi/thumb/v8-m.main/fp/include"
+// CHECK-V6M-C-SAME: "-x" "c++" "{{.*}}/baremetal-multilib.cpp"
+// CHECK-V6M-C-NEXT: "{{[^"]*}}ld{{(\.(lld|bfd|gold))?}}{{(\.exe)?}}" "{{.*}}.o" "-Bstatic"
+// CHECK-V6M-C-SAME: "-L{{.*}}/baremetal_multilib/bin/../lib/clang-runtimes/arm-none-eabi/thumb/v8-m.main/fp/lib"
+// CHECK-V6M-C-SAME: "-lc" "-lm" "-lclang_rt.builtins"
+// CHECK-V6M-C-SAME: "-o" "{{.*}}.o"

clang/test/Driver/baremetal.cpp

 // RUN:   | FileCheck %s --check-prefix=CHECK-SYSROOT-INC
 // CHECK-SYSROOT-INC-NOT: "-internal-isystem" "include"
 
 // RUN: %clang -no-canonical-prefixes %s -### --target=aarch64-none-elf 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-AARCH64-NO-HOST-INC %s
 // Verify that the bare metal driver does not include any host system paths:
 // CHECK-AARCH64-NO-HOST-INC: InstalledDir: [[INSTALLEDDIR:.+]]
 // CHECK-AARCH64-NO-HOST-INC: "-resource-dir" "[[RESOURCE:[^"]+]]"
-// CHECK-AARCH64-NO-HOST-INC-SAME: "-internal-isystem" "[[INSTALLEDDIR]]{{[/\\]+}}..{{[/\\]+}}lib{{[/\\]+}}clang-runtimes{{[/\\]+}}aarch64-none-elf{{[/\\]+}}include{{[/\\]+}}c++{{[/\\]+}}v1"
+// CHECK-AARCH64-NO-HOST-INC-SAME: "-internal-isystem" "[[INSTALLEDDIR]]{{[/\\]+}}..{{[/\\]+}}lib{{[/\\]+}}clang-runtimes{{[/\\]+}}aarch64-none-elf{{[/\\]+.*}}include{{[/\\]+}}c++{{[/\\]+}}v1"
 // CHECK-AARCH64-NO-HOST-INC-SAME: "-internal-isystem" "[[RESOURCE]]{{[/\\]+}}include"
-// CHECK-AARCH64-NO-HOST-INC-SAME: "-internal-isystem" "[[INSTALLEDDIR]]{{[/\\]+}}..{{[/\\]+}}lib{{[/\\]+}}clang-runtimes{{[/\\]+}}aarch64-none-elf{{[/\\]+}}include"
+// CHECK-AARCH64-NO-HOST-INC-SAME: "-internal-isystem" "[[INSTALLEDDIR]]{{[/\\]+}}..{{[/\\]+}}lib{{[/\\]+}}clang-runtimes{{[/\\]+}}aarch64-none-elf{{[/\\]+.*}}include"
 
 // RUN: %clang %s -### --target=riscv64-unknown-elf -o %t.out -L some/directory/user/asked/for \
 // RUN:     --sysroot=%S/Inputs/basic_riscv64_tree/riscv64-unknown-elf 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-RV64 %s
 // CHECK-RV64:      "-cc1" "-triple" "riscv64-unknown-unknown-elf"
 // CHECK-RV64-SAME: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
 // CHECK-RV64-SAME: "-isysroot" "[[SYSROOT:[^"]*]]"
 // CHECK-RV64-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}include{{[/\\]+}}c++{{[/\\]+}}v1"

clang/test/Driver/print-libgcc-file-name-clangrt.c

 // RUN: %clang -rtlib=compiler-rt -print-libgcc-file-name 2>&1 \
 // RUN:     --target=arm-linux-gnueabi -mfloat-abi=hard \
 // RUN:     -resource-dir=%S/Inputs/resource_dir_with_arch_subdir \
 // RUN:   | FileCheck --check-prefix=CHECK-CLANGRT-ARM-ABI %s
 // CHECK-CLANGRT-ARM-ABI: libclang_rt.builtins-armhf.a
 
 // RUN: %clang -rtlib=compiler-rt -print-libgcc-file-name 2>&1 \
 // RUN:     --target=armv7m-none-eabi \
+// RUN:     --sysroot=%S/Inputs/resource_dir_with_arch_subdir \
 // RUN:     -resource-dir=%S/Inputs/resource_dir_with_arch_subdir \
 // RUN:   | FileCheck --check-prefix=CHECK-CLANGRT-ARM-BAREMETAL %s
 // CHECK-CLANGRT-ARM-BAREMETAL: libclang_rt.builtins-armv7m.a
 
 // RUN: %clang -rtlib=compiler-rt -print-libgcc-file-name 2>&1 \
 // RUN:     --target=armv7m-vendor-none-eabi \
 // RUN:     -resource-dir=%S/Inputs/resource_dir_with_per_target_subdir \
 // RUN:   | FileCheck --check-prefix=CHECK-CLANGRT-ARM-BAREMETAL-PER-TARGET %s
 // CHECK-CLANGRT-ARM-BAREMETAL-PER-TARGET: libclang_rt.builtins.a

clang/unittests/Driver/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   MC
   Option
   Support
   TargetParser
   )
 
 add_clang_unittest(ClangDriverTests
   DistroTest.cpp
   DXCModeTest.cpp
   ToolChainTest.cpp
   ModuleCacheTest.cpp
   MultilibTest.cpp
+  Multilib2Test.cpp
   SanitizerArgsTest.cpp
   )
 
 clang_target_link_libraries(ClangDriverTests
   PRIVATE
   clangDriver
   clangBasic
   clangFrontend # For TextDiagnosticPrinter.
   )

clang/unittests/Driver/Multilib2Test.cpp

+//===- unittests/Driver/Multilib2Test.cpp --- Multilib2 tests ---------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Driver/Multilib2.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "gtest/gtest.h"
+
+using namespace clang::driver;
+using namespace clang;
+
+TEST(Multilib2Test, Parse) {
+  std::string O;
+  llvm::raw_string_ostream OS(O);
+
+  Multilib2 M;
+  EXPECT_FALSE(M.parse(R"(
+variants:
+- path: /abc
+)", OS));
+  EXPECT_TRUE(StringRef(O).contains("paths must be relative")) << O;
+
+  EXPECT_TRUE(M.parse(R"(
+variants:
+- path: .
+)", OS));
+  EXPECT_EQ(1U, M.size());
+  EXPECT_EQ("", std::get<0>(*M.begin()));
+
+  EXPECT_TRUE(M.parse(R"(
+variants:
+- path: abc
+)", OS));
+  EXPECT_EQ(1U, M.size());
+  EXPECT_EQ("/abc", std::get<0>(*M.begin()));
+
+  EXPECT_TRUE(M.parse(R"(
+variants:
+- path: pqr
+  args: [-mfloat-abi=soft]
+)", OS));
+  EXPECT_EQ(1U, M.size());
+  EXPECT_EQ("/pqr", std::get<0>(*M.begin()));
+  EXPECT_EQ(std::vector<std::string>({"-mfloat-abi=soft"}), std::get<1>(*M.begin()));
+
+  EXPECT_TRUE(M.parse(R"(
+variants:
+- path: pqr
+  args: [-mfloat-abi=soft, -fno-exceptions]
+)", OS));
+  EXPECT_EQ(1U, M.size());
+  EXPECT_EQ(std::vector<std::string>({"-mfloat-abi=soft", "-fno-exceptions"}), std::get<1>(*M.begin()));
+
+  EXPECT_TRUE(M.parse(R"(
+variants:
+- path: a
+- path: b
+)", OS));
+  EXPECT_EQ(2U, M.size());
+}
+
+TEST(Multilib2Test, SelectSoft) {
+  std::string O;
+  llvm::raw_string_ostream OS(O);
+  Multilib2 M;
+  ASSERT_TRUE(M.parse(R"(
+variants:
+- path: s
+  attrs: [softabi]
+arguments:
+- regex: -mfloat-abi soft
+  matchAttrs: [softabi]
+- regex: -mfloat-abi hard
+  matchAttrs: [hardabi]
+- regex: -msoft-float
+  noMatchAttrs: [hasfp]
+)", OS));
+  EXPECT_TRUE(M.select({"--target=arm-none-eabi"}).first);
+  EXPECT_TRUE(M.select({"--target=arm-none-eabi", "-mfloat-abi=soft"}).first);
+  EXPECT_TRUE(M.select({"--target=arm-none-eabi", "-mfloat-abi=softfp"}).first);
+  EXPECT_FALSE(M.select({"--target=arm-none-eabi", "-mfloat-abi=hard"}).first);
+  EXPECT_FALSE(M.select({"--target=arm-none-eabihf"}).first);
+}
+
+TEST(Multilib2Test, SelectSoftFP) {
+  std::string O;
+  llvm::raw_string_ostream OS(O);
+  Multilib2 M;
+  ASSERT_TRUE(M.parse(R"(
+variants:
+- path: f
+  attrs: [softabi, hasfp]
+arguments:
+- regex: -mfloat-abi soft
+  matchAttrs: [softabi]
+- regex: -mfloat-abi hard
+  matchAttrs: [hardabi]
+- regex: -msoft-float
+  noMatchAttrs: [hasfp]
+)", OS));
+  EXPECT_FALSE(M.select({"--target=arm-none-eabi", "-mfloat-abi=soft"}).first);
+  EXPECT_TRUE(M.select({"--target=arm-none-eabi", "-mfloat-abi=softfp"}).first);
+  EXPECT_FALSE(M.select({"--target=arm-none-eabi", "-mfloat-abi=hard"}).first);
+  EXPECT_FALSE(M.select({"--target=arm-none-eabihf"}).first);
+}
+
+TEST(Multilib2Test, SelectHard) {
+  // If hard float is all that's available then select that only if compiling with hard float.
+  std::string O;
+  llvm::raw_string_ostream OS(O);
+  Multilib2 M;
+  ASSERT_TRUE(M.parse(R"(
+variants:
+- path: h
+  attrs: [hardabi, hasfp]
+arguments:
+- regex: -mfloat-abi soft
+  matchAttrs: [softabi]
+- regex: -mfloat-abi hard
+  matchAttrs: [hardabi]
+- regex: -msoft-float
+  noMatchAttrs: [hasfp]
+)", OS));
+  EXPECT_FALSE(M.select({"--target=arm-none-eabi"}).first);
+  EXPECT_FALSE(M.select({"--target=arm-none-eabi", "-mfloat-abi=soft"}).first);
+  EXPECT_FALSE(M.select({"--target=arm-none-eabi", "-mfloat-abi=softfp"}).first);
+  EXPECT_TRUE(M.select({"--target=arm-none-eabi", "-mfloat-abi=hard"}).first);
+  EXPECT_TRUE(M.select({"--target=arm-none-eabihf"}).first);
+}
+
+TEST(Multilib2Test, SelectFloatABI) {
+  std::string O;
+  llvm::raw_string_ostream OS(O);
+  Multilib2 M;
+  ASSERT_TRUE(M.parse(R"(
+variants:
+- path: s
+  attrs: [softabi]
+- path: f
+  attrs: [softabi, hasfp]
+- path: h
+  attrs: [hardabi, hasfp]
+arguments:
+- regex: -mfloat-abi soft
+  matchAttrs: [softabi]
+- regex: -mfloat-abi hard
+  matchAttrs: [hardabi]
+- regex: -msoft-float
+  noMatchAttrs: [hasfp]
+)", OS));
+  EXPECT_EQ("/f", M.select({"--target=arm-none-eabi"}).second);
+  EXPECT_EQ("/s", M.select({"--target=arm-none-eabi", "-mfloat-abi=soft"}).second);
+  EXPECT_EQ("/f", M.select({"--target=arm-none-eabi", "-mfloat-abi=softfp"}).second);
+  EXPECT_EQ("/h", M.select({"--target=arm-none-eabi", "-mfloat-abi=hard"}).second);
+  EXPECT_EQ("/h", M.select({"--target=arm-none-eabihf"}).second);
+}
+
+TEST(Multilib2Test, SelectFloatABIReversed) {
+  // If soft is specified after softfp then softfp will never be
+  // selected because soft is compatible with softfp and last wins.
+  std::string O;
+  llvm::raw_string_ostream OS(O);
+  Multilib2 M;
+  ASSERT_TRUE(M.parse(R"(
+variants:
+- path: h
+  attrs: [hardabi, hasfp]
+- path: f
+  attrs: [softabi, hasfp]
+- path: s
+  attrs: [softabi]
+arguments:
+- regex: -mfloat-abi soft
+  matchAttrs: [softabi]
+- regex: -mfloat-abi hard
+  matchAttrs: [hardabi]
+- regex: -msoft-float
+  noMatchAttrs: [hasfp]
+)", OS));
+  EXPECT_EQ("/s", M.select({"--target=arm-none-eabi"}).second);
+  EXPECT_EQ("/s", M.select({"--target=arm-none-eabi", "-mfloat-abi=soft"}).second);
+  EXPECT_EQ("/s", M.select({"--target=arm-none-eabi", "-mfloat-abi=softfp"}).second);
+  EXPECT_EQ("/h", M.select({"--target=arm-none-eabi", "-mfloat-abi=hard"}).second);
+  EXPECT_EQ("/h", M.select({"--target=arm-none-eabihf"}).second);
+}
+
+TEST(Multilib2Test, SelectMClass) {
+  const StringRef MultilibSpec = R"(
+variants:
+- path: armv6m_soft_nofp
+  args: [--target=arm-none-eabi, -mfloat-abi=soft, -march=armv6m]
+  attrs: [thumb, soft, v6m]
+- path: armv7m_soft_nofp
+  args: [--target=arm-none-eabi, -mfloat-abi=soft, -march=armv7m+nofp]
+  attrs: [thumb, soft, v7m]
+- path: armv7em_soft_nofp
+  args: [--target=arm-none-eabi, -mfloat-abi=soft, -march=armv7em, -mfpu=none]
+  attrs: [thumb, soft, v7em]
+- path: armv8m.main_soft_nofp
+  args: [--target=arm-none-eabi, -mfloat-abi=soft, -march=armv8m.main+nofp]
+  attrs: [thumb, soft, v8m.main]
+- path: armv8.1m.main_soft_nofp_nomve
+  args: [--target=arm-none-eabi, -mfloat-abi=soft, -march=armv8.1m.main+nofp+nomve]
+  attrs: [thumb, soft, v8.1m.main]
+- path: armv7em_hard_fpv4_sp_d16
+  args: [--target=arm-none-eabi, -mfloat-abi=hard, -march=armv7em, -mfpu=fpv4-sp-d16]
+  attrs: [thumb, hard, v7em, vfp2sp]
+- path: armv7em_hard_fpv5_d16
+  args: [--target=arm-none-eabi, -mfloat-abi=hard, -march=armv7em, -mfpu=fpv5-d16]
+  attrs: [thumb, hard, v7em, fp-armv8d16sp]
+- path: armv8m.main_hard_fp
+  args: [--target=arm-none-eabi, -mfloat-abi=hard, -march=armv8m.main+fp]
+  attrs: [thumb, hard, v8m.main]
+- path: armv8.1m.main_hard_fp
+  args: [--target=arm-none-eabi, -mfloat-abi=hard, -march=armv8.1m.main+fp]
+  attrs: [thumb, hard, v8.1m.main, vfp2sp]
+- path: armv8.1m.main_hard_nofp_mve
+  args: [--target=arm-none-eabi, -mfloat-abi=hard, -march=armv8.1m.main+nofp+mve]
+  attrs: [thumb, hard, v8.1m.main, mve]
+arguments:
+- regex: -triple aarch64.*
+  matchAttrs: [aarch64]
+- regex: -triple thumb.*
+  matchAttrs: [thumb]
+- regex: -mfloat-abi soft
+  matchAttrs: [soft]
+- regex: -mfloat-abi hard
+  matchAttrs: [hard]
+- regex: -target-feature -fpregs
+  noMatchAttrs: [fpregs]
+- regex: -target-feature \+vfp2sp
+  matchAttrs: [vfp2sp]
+- regex: -target-feature \+fp-armv8d16sp
+  matchAttrs: [fp-armv8d16sp]
+- regex: -target-feature \+mve
+  matchAttrs: [mve]
+- regex: -triple .*v6m-.*
+  matchAttrs: [v6m]
+- regex: -triple .*v7m-.*
+  matchAttrs: [v7m, v6m]
+- regex: -triple .*v7em-.*
+  matchAttrs: [v7em, v7m, v6m]
+- regex: -triple .*v8m\.base-.*
+  matchAttrs: [v8m.base, v6m]
+- regex: -triple .*v8m\.main-.*
+  matchAttrs: [v8m.main, v7em, v7m, v6m]
+- regex: -triple .*v8\.[0-9]+m\.base-.*
+  matchAttrs: [v8m.base, v6m]
+- regex: -triple .*v8\.[0-9]+m\.main-.*
+  matchAttrs: [v8.1m.main, v8m.main, v7em, v7m, v6m]
+)";
+
+  std::string O;
+  llvm::raw_string_ostream OS(O);
+  Multilib2 M;
+  ASSERT_TRUE(M.parse(MultilibSpec, OS));
+
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv6m_soft_nofp")), M.select({"--target=arm-none-eabi", "-mfloat-abi=soft", "-march=armv6m"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv7m_soft_nofp")), M.select({"--target=arm-none-eabi", "-mfloat-abi=soft", "-march=armv7m+nofp"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv7em_soft_nofp")), M.select({"--target=arm-none-eabi", "-mfloat-abi=soft", "-march=armv7em", "-mfpu=none"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv8m.main_soft_nofp")), M.select({"--target=arm-none-eabi", "-mfloat-abi=soft", "-march=armv8m.main+nofp"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv8.1m.main_soft_nofp_nomve")), M.select({"--target=arm-none-eabi", "-mfloat-abi=soft", "-march=armv8.1m.main+nofp+nomve"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv7em_hard_fpv4_sp_d16")), M.select({"--target=arm-none-eabi", "-mfloat-abi=hard", "-march=armv7em", "-mfpu=fpv4-sp-d16"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv7em_hard_fpv5_d16")), M.select({"--target=arm-none-eabi", "-mfloat-abi=hard", "-march=armv7em", "-mfpu=fpv5-d16"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv8m.main_hard_fp")), M.select({"--target=arm-none-eabi", "-mfloat-abi=hard", "-march=armv8m.main+fp"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv8.1m.main_hard_fp")), M.select({"--target=arm-none-eabi", "-mfloat-abi=hard", "-march=armv8.1m.main+fp"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv8.1m.main_hard_nofp_mve")), M.select({"--target=arm-none-eabi", "-mfloat-abi=hard", "-march=armv8.1m.main+nofp+mve"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv6m_soft_nofp")), M.select({"--target=arm-none-eabi", "-mcpu=cortex-m0"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv6m_soft_nofp")), M.select({"--target=arm-none-eabi", "-mcpu=cortex-m0+"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv6m_soft_nofp")), M.select({"--target=arm-none-eabi", "-mcpu=cortex-m1"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv7m_soft_nofp")), M.select({"--target=arm-none-eabi", "-mcpu=cortex-m3"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv7em_hard_fpv4_sp_d16")), M.select({"--target=arm-none-eabihf", "-mcpu=cortex-m4"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv7em_hard_fpv5_d16")), M.select({"--target=arm-none-eabihf", "-mcpu=cortex-m7"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv6m_soft_nofp")), M.select({"--target=arm-none-eabi", "-mcpu=cortex-m23"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv8m.main_hard_fp")), M.select({"--target=arm-none-eabihf", "-mcpu=cortex-m33"}));
+  EXPECT_EQ((std::pair<bool, std::string>(true, "/armv8.1m.main_hard_nofp_mve")), M.select({"--target=arm-none-eabihf", "-mcpu=cortex-m55"}));
+}