[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 ↗

(On Diff #196171)

Doesn't seem to be used?

271 ↗

(On Diff #196171)

llvm::sort.

[mcgrathr]

lgtm

clang/include/clang/Driver/Multilib.h

81 ↗

(On Diff #196331)

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.

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. When more than one multilib matches flags,
+  /// the one with the highest priority is selected, with 0 being the default.
+  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) {

lib/Driver/Multilib.cpp

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 {

unittests/Driver/MultilibTest.cpp

TEST(MultilibTest, SetCombineWith) {
   Milk.push_back(Multilib("milk"));
   MultilibSet Latte;
   ASSERT_EQ(Latte.size(), (unsigned)0);
   Latte.combineWith(Coffee);
   ASSERT_EQ(Latte.size(), (unsigned)1);
   Latte.combineWith(Milk);
   ASSERT_EQ(Latte.size(), (unsigned)2);
 }
+
+TEST(MultilibTest, SetPriority) {
+  MultilibSet MS;
+  MS.push_back(Multilib("foo", {}, {}, 1).flag("+foo"));
+  MS.push_back(Multilib("bar", {}, {}, 2).flag("+bar"));
+
+  Multilib::flags_list Flags1;
+  Flags1.push_back("+foo");
+  Flags1.push_back("-bar");
+  Multilib Selection1;
+  ASSERT_TRUE(MS.select(Flags1, Selection1))
+      << "Flag set was {\"+foo\"}, but selection not found";
+  ASSERT_TRUE(Selection1.gccSuffix() == "/foo")
+      << "Selection picked " << Selection1 << " which was not expected";
+
+  Multilib::flags_list Flags2;
+  Flags2.push_back("+foo");
+  Flags2.push_back("+bar");
+  Multilib Selection2;
+  ASSERT_TRUE(MS.select(Flags2, Selection2))
+      << "Flag set was {\"+bar\"}, but selection not found";
+  ASSERT_TRUE(Selection2.gccSuffix() == "/bar")
+      << "Selection picked " << Selection2 << " which was not expected";
+}