[Driver] Support priority for multilibs

[phosek]

Summary

When more than one multilib flag matches, try to select the best
possible match based on priority. When two different multilibs with
the same same priority match, we still throw an error matching the
existing behavior.

[lebedev.ri]

Can this have test coverage?

clang/lib/Driver/Multilib.cpp

22

Doesn't seem to be used?

270

llvm::sort.

[mcgrathr]

lgtm

clang/include/clang/Driver/Multilib.h

81

Say explicitly that the greatest priority is chosen (sometimes 0 is "best").

[phosek]

In D60990#1475116, @lebedev.ri wrote:

Can this have test coverage?

Done, I've added a test.

clang/include/clang/Driver/Multilib.h

 public:
   using flags_list = std::vector<std::string>;
 
 private:
   std::string GCCSuffix;
   std::string OSSuffix;
   std::string IncludeSuffix;
   flags_list Flags;
+  int Priority;
 
 public:
   Multilib(StringRef GCCSuffix = {}, StringRef OSSuffix = {},
-           StringRef IncludeSuffix = {});
+           StringRef IncludeSuffix = {}, int Priority = 0);
 
   /// Get the detected GCC installation path suffix for the multi-arch
   /// target variant. Always starts with a '/', unless empty
   const std::string &gccSuffix() const {
     assert(GCCSuffix.empty() ||
            (StringRef(GCCSuffix).front() == '/' && GCCSuffix.size() > 1));
     return GCCSuffix;
   }
public:
   /// Set the include directory suffix
   Multilib &includeSuffix(StringRef S);
 
   /// Get the flags that indicate or contraindicate this multilib's use
   /// All elements begin with either '+' or '-'
   const flags_list &flags() const { return Flags; }
   flags_list &flags() { return Flags; }
 
+  /// Returns the multilib priority.
+  int priority() const { return Priority; }
+
   /// Add a flag to the flags list
   /// \p Flag must be a flag accepted by the driver with its leading '-' removed,
   ///     and replaced with either:
   ///       '-' which contraindicates using this multilib with that flag
   ///     or:
   ///       '+' which promotes using this multilib in the presence of that flag
   ///     otherwise '-print-multi-lib' will not emit them correctly.
   Multilib &flag(StringRef F) {

clang/lib/Driver/Multilib.cpp

 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <string>
 
 using namespace clang;
 using namespace driver;
 using namespace llvm::sys;
 
 /// normalize Segment to "/foo/bar" or "".
 static void normalizePathSegment(std::string &Segment) {
   StringRef seg = Segment;
static void normalizePathSegment(std::string &Segment) {
   if (seg.front() != '/') {
     Segment = "/" + seg.str();
   } else {
     Segment = seg;
   }
 }
 
 Multilib::Multilib(StringRef GCCSuffix, StringRef OSSuffix,
-                   StringRef IncludeSuffix)
-    : GCCSuffix(GCCSuffix), OSSuffix(OSSuffix), IncludeSuffix(IncludeSuffix) {
+                   StringRef IncludeSuffix, int Priority)
+    : GCCSuffix(GCCSuffix), OSSuffix(OSSuffix), IncludeSuffix(IncludeSuffix),
+      Priority(Priority) {
   normalizePathSegment(this->GCCSuffix);
   normalizePathSegment(this->OSSuffix);
   normalizePathSegment(this->IncludeSuffix);
 }
 
 Multilib &Multilib::gccSuffix(StringRef S) {
   GCCSuffix = S;
   normalizePathSegment(GCCSuffix);
bool MultilibSet::select(const Multilib::flags_list &Flags, Multilib &M) const {
 
   if (Filtered.empty())
     return false;
   if (Filtered.size() == 1) {
     M = Filtered[0];
     return true;
   }
 
-  // TODO: pick the "best" multlib when more than one is suitable
-  assert(false);
+  // Sort multilibs by priority and select the one with the highest priority.
+  llvm::sort(Filtered.begin(), Filtered.end(),
+             [](const Multilib &a, const Multilib &b) -> bool {
+               return a.priority() > b.priority();
+             });
+
+  if (Filtered[0].priority() > Filtered[1].priority()) {
+    M = Filtered[0];
+    return true;
+  }
+
+  // TODO: We should consider returning llvm::Error rather than aborting.
+  assert(false && "More than one multilib with the same priority");
   return false;
 }
 
 LLVM_DUMP_METHOD void MultilibSet::dump() const {
   print(llvm::errs());
 }
 
 void MultilibSet::print(raw_ostream &OS) const {