[Driver] Rename multilib flags to tags

[michaelplatings]

Summary

The name "flag" implies a type of command line option which is no longer
how these variables are used in multilib. Although tags often look
similar to command line options this is not a requirement - tags may be
arbitrary strings.

MultilibBuilder still uses the name "flag" since it is designed to be
used only with valid command line options, even though these are
subsequently used as multilib tags. Similarly addMultilibFlag() keeps
its existing name because of how it is used, even though it now takes a
tag_set argument.

[MaskRay]

Since the touched code is still in review, you need to merge the changes into the prior patches.

[simon_tatham]

But it was useful to have it separate at least for review purposes, since it made it much easier when Michael asked me to proofread the change from 'flags' to 'tags'!

clang/docs/Multilib.rst

66 ↗

(On Diff #503293)

An "option" here seems to be the same thing as an "argument" elsewhere in this paragraph. Since the terminology is already confusing, perhaps simplify by using the same word consistently throughout? I think "option" is more precise, because positional clang arguments like input files definitely don't play a part in this mechanism.

182 ↗

(On Diff #503293)

That capital V looks unintentional to me, and is potentially confusing – someone might go looking for a formal definition of it somewhere.

clang/include/clang/Driver/Multilib.h

63–64

Tags are arbitrary strings, some of which are derived from command-line options and look similar to them, and others can be defined by a particular multilib.yaml

[simon_tatham]

clang/docs/Multilib.rst

71 ↗

(On Diff #503293)

This is a particular case where "option" seems like a better word. Not every argument has a leading - in the first place. But every option does.

(Or, at least, in the default Unix / gcc style of clang options. I suppose in clang-cl even that is not true, because options can have a leading / in Windows style. I assume that in that situation the options are normalised to their GNU representation before converting into multilib selection tags?)

[michaelplatings]

Thanks @MaskRay for taking a look and thanks @simon_tatham for the review of the change. This change affects existing code so I think it deserves its own commit, but I'll move it down the stack to before D142932 so that later changes use the new names immediately, and I'll incorporate Simon's suggestions into those.

clang/docs/Multilib.rst

66 ↗

(On Diff #503293)

I'll incorporate this into D143587.

71 ↗

(On Diff #503293)

I'll incorporate this into D143587.

182 ↗

(On Diff #503293)

I'll incorporate this into D143587.

clang/include/clang/Driver/Multilib.h

63–64

I'll move this change to earlier in the stack before multilib.yaml is a thing, but then I'll update the comment with your suggestion in D142932.

[michaelplatings]

Rebase on top of D142905

[michaelplatings]

Tiny tweak: undo an unnecessary change to a test

[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.
From looking at the source code alone - assuming that most people would not track down the commit message/review for extra context - I found it difficult to work out the convention for when Flags is used and when Tags is used. I've made a suggestion for some comments. This can be applied prior to commit if you want to take it up.

clang/lib/Driver/ToolChains/CommonArgs.h

202

I can see the reason to keep the name addMultilibFlag. At this point is the tag_set expected to be simplified tags or full command line flags. If it is the former I think it would be good to change Flags to Tags here.

May also be useul to add a \p for Flags (or Tags) if there are any requirements, or just useful information on what it is expected to be.

Parameter name also applies to CommonArgs.cpp below.

[peter.smith]

Actually click the button this time to set approval, see previous comment.

[michaelplatings]

Thanks @peter.smith. I've opted to leave the comment as-is. If we can expect a tag_set to actually contain flags then I've continued to use that terminology.

clang/lib/Driver/ToolChains/CommonArgs.h

202

For the way this function is used I would expect Flags to be command line flags prefixed with + or -, the same as for the Flag parameter. Therefore I think it best to leave it as-is.

[michaelplatings]

We're going back to "flags": https://discourse.llvm.org/t/rfc-multilib/67494/14

clang/include/clang/Driver/Multilib.h

 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace clang {
 namespace driver {
 
-/// This corresponds to a single GCC Multilib, or a segment of one controlled
-/// by a command line flag.
+/// This corresponds to a single GCC Multilib.
 /// See also MultilibBuilder for building a multilib by mutating it
 /// incrementally.
 class Multilib {
 public:
-  using flag_set = std::set<std::string>;
+  using tag_set = std::set<std::string>;
   using option_list = std::vector<std::string>;
 
 private:
   std::string GCCSuffix;
   std::string OSSuffix;
   std::string IncludeSuffix;
-  flag_set Flags;
+  tag_set Tags;
   option_list PrintOptions;
 
 public:
   /// GCCSuffix, OSSuffix & IncludeSuffix will be appended directly to the
   /// sysroot string so they must either be empty or begin with a '/' character.
   /// This is enforced with an assert in the constructor.
   Multilib(StringRef GCCSuffix = {}, StringRef OSSuffix = {},
-           StringRef IncludeSuffix = {}, const flag_set &Flags = flag_set(),
+           StringRef IncludeSuffix = {}, const tag_set &Tags = tag_set(),
            const option_list &PrintOptions = option_list());
 
   /// Get the detected GCC installation path suffix for the multi-arch
   /// target variant. Always starts with a '/', unless empty
   const std::string &gccSuffix() const { return GCCSuffix; }
 
   /// Get the detected os path suffix for the multi-arch
   /// target variant. Always starts with a '/', unless empty
   const std::string &osSuffix() const { return OSSuffix; }
 
   /// Get the include directory suffix. Always starts with a '/', unless
   /// empty
   const std::string &includeSuffix() const { return IncludeSuffix; }
 
-  /// Get the set of flags that indicate this multilib's use.
-  /// Flags are arbitrary strings although typically they will look similar to
-  /// command line options. A multilib is considered compatible if its flags are
-  /// a subset of the flags derived from the Clang command line options.
-  const flag_set &flags() const { return Flags; }
+  /// Get the set of tags that indicate this multilib's use.
+  /// Tags are arbitrary strings although typically they will look similar to
+  /// command line options. A multilib is considered compatible if its tags are
+  /// a subset of the tags derived from the Clang command line options.
+  const tag_set &tags() const { return Tags; }
 
   /// Returns the options that should be used for clang -print-multi-lib
   const option_list &getPrintOptions() const { return PrintOptions; }
 
   LLVM_DUMP_METHOD void dump() const;
   /// print summary of the Multilib
   void print(raw_ostream &OS) const;
 
public:
 
   /// 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::flag_set &Flags) const;
+  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::flag_set &Flags, Multilib &M) const;
+  bool select(const Multilib::tag_set &Tags, Multilib &M) const;
 
   unsigned size() const { return Multilibs.size(); }
 
   LLVM_DUMP_METHOD void dump() const;
   void print(raw_ostream &OS) const;
 
   MultilibSet &setIncludeDirsCallback(IncludeDirsFunc F) {
     IncludeCallback = std::move(F);

clang/lib/Driver/Multilib.cpp

 #include <cassert>
 #include <string>
 
 using namespace clang;
 using namespace driver;
 using namespace llvm::sys;
 
 Multilib::Multilib(StringRef GCCSuffix, StringRef OSSuffix,
-                   StringRef IncludeSuffix, const flag_set &Flags,
+                   StringRef IncludeSuffix, const tag_set &Tags,
                    const option_list &PrintOptions)
     : GCCSuffix(GCCSuffix), OSSuffix(OSSuffix), IncludeSuffix(IncludeSuffix),
-      Flags(Flags), PrintOptions(PrintOptions) {
+      Tags(Tags), PrintOptions(PrintOptions) {
   assert(GCCSuffix.empty() ||
          (StringRef(GCCSuffix).front() == '/' && GCCSuffix.size() > 1));
   assert(OSSuffix.empty() ||
          (StringRef(OSSuffix).front() == '/' && OSSuffix.size() > 1));
   assert(IncludeSuffix.empty() ||
          (StringRef(IncludeSuffix).front() == '/' && IncludeSuffix.size() > 1));
 }
 
 LLVM_DUMP_METHOD void Multilib::dump() const {
   print(llvm::errs());
 }
 
 void Multilib::print(raw_ostream &OS) const {
   if (GCCSuffix.empty())
     OS << ".";
   else
     OS << StringRef(GCCSuffix).drop_front();
   OS << ";";
   for (StringRef Option : PrintOptions)
     OS << "@" << Option.substr(1);
 }
 
 bool Multilib::operator==(const Multilib &Other) const {
-  if (Flags != Other.Flags)
+  if (Tags != Other.Tags)
     return false;
 
   if (osSuffix() != Other.osSuffix())
     return false;
 
   if (gccSuffix() != Other.gccSuffix())
     return false;
 

 MultilibSet &MultilibSet::FilterOut(FilterCallback F) {
   llvm::erase_if(Multilibs, F);
   return *this;
 }
 
 void MultilibSet::push_back(const Multilib &M) { Multilibs.push_back(M); }
 
 MultilibSet::multilib_list
-MultilibSet::select(const Multilib::flag_set &Flags) const {
+MultilibSet::select(const Multilib::tag_set &Tags) const {
   multilib_list Result;
   llvm::copy_if(Multilibs, std::back_inserter(Result),
-                [&Flags](const Multilib &M) {
-                  return std::includes(Flags.begin(), Flags.end(),
-                                       M.flags().begin(), M.flags().end());
+                [&Tags](const Multilib &M) {
+                  return std::includes(Tags.begin(), Tags.end(),
+                                       M.tags().begin(), M.tags().end());
                 });
   return Result;
 }
 
-bool MultilibSet::select(const Multilib::flag_set &Flags,
+bool MultilibSet::select(const Multilib::tag_set &Tags,
                          Multilib &Selected) const {
-  multilib_list Result = select(Flags);
+  multilib_list Result = select(Tags);
   if (Result.empty())
     return false;
   Selected = Result.back();
   return true;
 }
 
 LLVM_DUMP_METHOD void MultilibSet::dump() const {
   print(llvm::errs());

clang/lib/Driver/MultilibBuilder.cpp

for (unsigned I = 0, N = Flags.size(); I != N; ++I) {
     else if (Flags[I] != Flags[SI->getValue()])
       return false;
   }
   return true;
 }
 
 Multilib MultilibBuilder::makeMultilib() const {
   // Derive print options from flags.
-  // In general, flags in the Multilib class are not required to be valid
+  // In general, tags in the Multilib class are not required to be valid
   // command line options, but for the MultilibBuilder class flags are expected
   // to form valid command line options when their first character is replaced
   // with '-'.
   Multilib::option_list PrintOptions;
   for (StringRef Flag : Flags) {
     if (Flag.front() == '+')
       PrintOptions.push_back(("-" + Flag.substr(1)).str());
   }
   return Multilib(GCCSuffix, OSSuffix, IncludeSuffix,
-                  Multilib::flag_set(Flags.begin(), Flags.end()), PrintOptions);
+                  Multilib::tag_set(Flags.begin(), Flags.end()), PrintOptions);
 }
 
 MultilibSetBuilder &MultilibSetBuilder::Maybe(const MultilibBuilder &M) {
   MultilibBuilder Opposite;
   // Negate any '+' flags
   for (StringRef Flag : M.flags()) {
     if (Flag.front() == '+')
       Opposite.flags().push_back(("-" + Flag.substr(1)).str());

clang/lib/Driver/ToolChains/BareMetal.cpp

 using namespace clang;
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang::driver::toolchains;
 
 static bool findRISCVMultilibs(const Driver &D,
                                const llvm::Triple &TargetTriple,
                                const ArgList &Args, DetectedMultilibs &Result) {
-  Multilib::flag_set Flags;
+  Multilib::tag_set Flags;
   StringRef Arch = riscv::getRISCVArch(Args, TargetTriple);
   StringRef Abi = tools::riscv::getRISCVABI(Args, TargetTriple);
 
   if (TargetTriple.isRISCV64()) {
     MultilibBuilder Imac =
         MultilibBuilder().flag("+march=rv64imac").flag("+mabi=lp64");
     MultilibBuilder Imafdc = MultilibBuilder("/rv64imafdc/lp64d")
                                  .flag("+march=rv64imafdc")

clang/lib/Driver/ToolChains/CommonArgs.h

 /// to.
 SmallString<128> getStatsFileName(const llvm::opt::ArgList &Args,
                                   const InputInfo &Output,
                                   const InputInfo &Input, const Driver &D);
 
 /// \p Flag must be a flag accepted by the driver with its leading '-' removed,
 //     otherwise '-print-multi-lib' will not emit them correctly.
 void addMultilibFlag(bool Enabled, const char *const Flag,
-                     Multilib::flag_set &Flags);
+                     Multilib::tag_set &Flags);
 
 void addX86AlignBranchArgs(const Driver &D, const llvm::opt::ArgList &Args,
                            llvm::opt::ArgStringList &CmdArgs, bool IsLTO,
                            const StringRef PluginOptPrefix = "");
 
 void checkAMDGPUCodeObjectVersion(const Driver &D,
                                   const llvm::opt::ArgList &Args);
 
 unsigned getAMDGPUCodeObjectVersion(const Driver &D,

clang/lib/Driver/ToolChains/CommonArgs.cpp

SmallString<128> tools::getStatsFileName(const llvm::opt::ArgList &Args,
 
   StringRef BaseName = llvm::sys::path::filename(Input.getBaseInput());
   llvm::sys::path::append(StatsFile, BaseName);
   llvm::sys::path::replace_extension(StatsFile, "stats");
   return StatsFile;
 }
 
 void tools::addMultilibFlag(bool Enabled, const char *const Flag,
-                            Multilib::flag_set &Flags) {
+                            Multilib::tag_set &Flags) {
   Flags.insert(std::string(Enabled ? "+" : "-") + Flag);
 }
 
 void tools::addX86AlignBranchArgs(const Driver &D, const ArgList &Args,
                                   ArgStringList &CmdArgs, bool IsLTO,
                                   const StringRef PluginOptPrefix) {
   auto addArg = [&, IsLTO](const Twine &Arg) {
     if (IsLTO) {

clang/lib/Driver/ToolChains/Fuchsia.cpp

Multilibs.push_back(MultilibBuilder("compat", {}, {})
                           .flag("+fc++-abi=itanium")
                           .makeMultilib());
 
   Multilibs.FilterOut([&](const Multilib &M) {
     std::vector<std::string> RD = FilePaths(M);
     return llvm::all_of(RD, [&](std::string P) { return !getVFS().exists(P); });
   });
 
-  Multilib::flag_set Flags;
+  Multilib::tag_set Flags;
   bool Exceptions =
       Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions, true);
   addMultilibFlag(Exceptions, "fexceptions", Flags);
   addMultilibFlag(!Exceptions, "fno-exceptions", Flags);
   addMultilibFlag(getSanitizerArgs(Args).needsAsanRt(), "fsanitize=address",
                   Flags);
   addMultilibFlag(getSanitizerArgs(Args).needsHwasanRt(), "fsanitize=hwaddress",
                   Flags);

clang/lib/Driver/ToolChains/Gnu.cpp

static bool isMicroMips(const ArgList &Args) {
   Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
   return A && A->getOption().matches(options::OPT_mmicromips);
 }
 
 static bool isMSP430(llvm::Triple::ArchType Arch) {
   return Arch == llvm::Triple::msp430;
 }
 
-static bool findMipsCsMultilibs(const Multilib::flag_set &Flags,
+static bool findMipsCsMultilibs(const Multilib::tag_set &Flags,
                                 FilterNonExistent &NonExistent,
                                 DetectedMultilibs &Result) {
   // Check for Code Sourcery toolchain multilibs
   MultilibSet CSMipsMultilibs;
   {
     auto MArchMips16 = MultilibBuilder("/mips16").flag("+m32").flag("+mips16");
 
     auto MArchMicroMips =
if (Candidate->select(Flags, Result.SelectedMultilib)) {
       Result.Multilibs = *Candidate;
       return true;
     }
   }
   return false;
 }
 
 static bool findMipsAndroidMultilibs(llvm::vfs::FileSystem &VFS, StringRef Path,
-                                     const Multilib::flag_set &Flags,
+                                     const Multilib::tag_set &Flags,
                                      FilterNonExistent &NonExistent,
                                      DetectedMultilibs &Result) {
 
   MultilibSet AndroidMipsMultilibs =
       MultilibSetBuilder()
           .Maybe(MultilibBuilder("/mips-r2", {}, {}).flag("+march=mips32r2"))
           .Maybe(MultilibBuilder("/mips-r6", {}, {}).flag("+march=mips32r6"))
           .makeMultilibSet()
else if (VFS.exists(Path + "/32"))
     MS = &AndroidMips64elMultilibs;
   if (MS->select(Flags, Result.SelectedMultilib)) {
     Result.Multilibs = *MS;
     return true;
   }
   return false;
 }
 
-static bool findMipsMuslMultilibs(const Multilib::flag_set &Flags,
+static bool findMipsMuslMultilibs(const Multilib::tag_set &Flags,
                                   FilterNonExistent &NonExistent,
                                   DetectedMultilibs &Result) {
   // Musl toolchain multilibs
   MultilibSet MuslMipsMultilibs;
   {
     auto MArchMipsR2 = MultilibBuilder("")
                            .osSuffix("/mips-r2-hard-musl")
                            .flag("+EB")
static bool findMipsMuslMultilibs(const Multilib::tag_set &Flags,
   }
   if (MuslMipsMultilibs.select(Flags, Result.SelectedMultilib)) {
     Result.Multilibs = MuslMipsMultilibs;
     return true;
   }
   return false;
 }
 
-static bool findMipsMtiMultilibs(const Multilib::flag_set &Flags,
+static bool findMipsMtiMultilibs(const Multilib::tag_set &Flags,
                                  FilterNonExistent &NonExistent,
                                  DetectedMultilibs &Result) {
   // CodeScape MTI toolchain v1.2 and early.
   MultilibSet MtiMipsMultilibsV1;
   {
     auto MArchMips32 = MultilibBuilder("/mips32")
                            .flag("+m32")
                            .flag("-m64")
for (auto *Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
     if (Candidate->select(Flags, Result.SelectedMultilib)) {
       Result.Multilibs = *Candidate;
       return true;
     }
   }
   return false;
 }
 
-static bool findMipsImgMultilibs(const Multilib::flag_set &Flags,
+static bool findMipsImgMultilibs(const Multilib::tag_set &Flags,
                                  FilterNonExistent &NonExistent,
                                  DetectedMultilibs &Result) {
   // CodeScape IMG toolchain v1.2 and early.
   MultilibSet ImgMultilibsV1;
   {
     auto Mips64r6 = MultilibBuilder("/mips64r6").flag("+m64").flag("-m32");
 
     auto LittleEndian = MultilibBuilder("/el").flag("+EL").flag("-EB");
bool clang::driver::findMIPSMultilibs(const Driver &D,
   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
 
   StringRef CPUName;
   StringRef ABIName;
   tools::mips::getMipsCPUAndABI(Args, TargetTriple, CPUName, ABIName);
 
   llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
 
-  Multilib::flag_set Flags;
+  Multilib::tag_set Flags;
   addMultilibFlag(TargetTriple.isMIPS32(), "m32", Flags);
   addMultilibFlag(TargetTriple.isMIPS64(), "m64", Flags);
   addMultilibFlag(isMips16(Args), "mips16", Flags);
   addMultilibFlag(CPUName == "mips32", "march=mips32", Flags);
   addMultilibFlag(CPUName == "mips32r2" || CPUName == "mips32r3" ||
                       CPUName == "mips32r5" || CPUName == "p5600",
                   "march=mips32r2", Flags);
   addMultilibFlag(CPUName == "mips32r6", "march=mips32r6", Flags);
MultilibBuilder DefaultMultilib =
       MultilibBuilder("").flag("-march=armv7-a").flag("-mthumb");
   MultilibSet AndroidArmMultilibs =
       MultilibSetBuilder()
           .Either(ThumbMultilib, ArmV7Multilib, ArmV7ThumbMultilib,
                   DefaultMultilib)
           .makeMultilibSet()
           .FilterOut(NonExistent);
 
-  Multilib::flag_set Flags;
+  Multilib::tag_set Flags;
   llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
   bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
   bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
   bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
   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) &&
static bool findMSP430Multilibs(const Driver &D,
   // FIXME: when clang starts to support msp430x ISA additional logic
   // to select between multilib must be implemented
   // MultilibBuilder MSP430xMultilib = MultilibBuilder("/large");
 
   Result.Multilibs.push_back(WithoutExceptions.makeMultilib());
   Result.Multilibs.push_back(WithExceptions.makeMultilib());
   Result.Multilibs.FilterOut(NonExistent);
 
-  Multilib::flag_set Flags;
+  Multilib::tag_set Flags;
   addMultilibFlag(Args.hasFlag(options::OPT_fexceptions,
                                options::OPT_fno_exceptions, false),
                   "exceptions", Flags);
   if (Result.Multilibs.select(Flags, Result.SelectedMultilib))
     return true;
 
   return false;
 }
 
 static void findCSKYMultilibs(const Driver &D, const llvm::Triple &TargetTriple,
                               StringRef Path, const ArgList &Args,
                               DetectedMultilibs &Result) {
   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
 
   tools::csky::FloatABI TheFloatABI = tools::csky::getCSKYFloatABI(D, Args);
   std::optional<llvm::StringRef> Res =
       tools::csky::getCSKYArchName(D, Args, TargetTriple);
 
   if (!Res)
     return;
   auto ARCHName = *Res;
 
-  Multilib::flag_set Flags;
+  Multilib::tag_set Flags;
   addMultilibFlag(TheFloatABI == tools::csky::FloatABI::Hard, "hard-fp", Flags);
   addMultilibFlag(TheFloatABI == tools::csky::FloatABI::SoftFP, "soft-fp",
                   Flags);
   addMultilibFlag(TheFloatABI == tools::csky::FloatABI::Soft, "soft", Flags);
   addMultilibFlag(ARCHName == "ck801", "march=ck801", Flags);
   addMultilibFlag(ARCHName == "ck802", "march=ck802", Flags);
   addMultilibFlag(ARCHName == "ck803", "march=ck803", Flags);
   addMultilibFlag(ARCHName == "ck804", "march=ck804", Flags);
MultilibSet RISCVMultilibs =
           .FilterOut(NonExistent)
           .setFilePathsCallback([](const Multilib &M) {
             return std::vector<std::string>(
                 {M.gccSuffix(),
                  "/../../../../riscv64-unknown-elf/lib" + M.gccSuffix(),
                  "/../../../../riscv32-unknown-elf/lib" + M.gccSuffix()});
           });
 
-  Multilib::flag_set Flags;
+  Multilib::tag_set Flags;
   llvm::StringSet<> Added_ABIs;
   StringRef ABIName = tools::riscv::getRISCVABI(Args, TargetTriple);
   StringRef MArch = tools::riscv::getRISCVArch(Args, TargetTriple);
   for (auto Element : RISCVMultilibSet) {
     addMultilibFlag(MArch == Element.march,
                     Twine("march=", Element.march).str().c_str(), Flags);
     if (!Added_ABIs.count(Element.mabi)) {
       Added_ABIs.insert(Element.mabi);
static void findRISCVMultilibs(const Driver &D,
   MultilibBuilder Lp64d =
       MultilibBuilder("lib64/lp64d").flag("+m64").flag("+mabi=lp64d");
   MultilibSet RISCVMultilibs =
       MultilibSetBuilder()
           .Either({Ilp32, Ilp32f, Ilp32d, Lp64, Lp64f, Lp64d})
           .makeMultilibSet()
           .FilterOut(NonExistent);
 
-  Multilib::flag_set Flags;
+  Multilib::tag_set Flags;
   bool IsRV64 = TargetTriple.getArch() == llvm::Triple::riscv64;
   StringRef ABIName = tools::riscv::getRISCVABI(Args, TargetTriple);
 
   addMultilibFlag(!IsRV64, "m32", Flags);
   addMultilibFlag(IsRV64, "m64", Flags);
   addMultilibFlag(ABIName == "ilp32", "mabi=ilp32", Flags);
   addMultilibFlag(ABIName == "ilp32f", "mabi=ilp32f", Flags);
   addMultilibFlag(ABIName == "ilp32d", "mabi=ilp32d", Flags);
static bool findBiarchMultilibs(const Driver &D,
 
   Result.Multilibs.push_back(Default);
   Result.Multilibs.push_back(Alt64);
   Result.Multilibs.push_back(Alt32);
   Result.Multilibs.push_back(Altx32);
 
   Result.Multilibs.FilterOut(NonExistent);
 
-  Multilib::flag_set Flags;
+  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))
     return false;
 
   if (Result.SelectedMultilib == Alt64 || Result.SelectedMultilib == Alt32 ||

clang/unittests/Driver/MultilibBuilderTest.cpp

 TEST(MultilibBuilderTest, SetConstruction1) {
   // Single maybe
   MultilibSet MS = MultilibSetBuilder()
                        .Maybe(MultilibBuilder("64").flag("+m64"))
                        .makeMultilibSet();
   ASSERT_TRUE(MS.size() == 2);
   for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) {
     if (I->gccSuffix() == "/64")
-      ASSERT_TRUE(*I->flags().begin() == "+m64");
+      ASSERT_TRUE(*I->tags().begin() == "+m64");
     else if (I->gccSuffix() == "")
-      ASSERT_TRUE(*I->flags().begin() == "-m64");
+      ASSERT_TRUE(*I->tags().begin() == "-m64");
     else
       FAIL() << "Unrecognized gccSufix: " << I->gccSuffix();
   }
 }
 
 TEST(MultilibBuilderTest, SetConstruction2) {
   // Double maybe
   MultilibSet MS = MultilibSetBuilder()
                        .Maybe(MultilibBuilder("sof").flag("+sof"))
                        .Maybe(MultilibBuilder("el").flag("+EL"))
                        .makeMultilibSet();
   ASSERT_TRUE(MS.size() == 4);
   for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) {
     ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
                     .Cases("", "/sof", "/el", "/sof/el", true)
                     .Default(false))
         << "Multilib " << *I << " wasn't expected";
     ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
-                    .Case("", is_contained(I->flags(), "-sof"))
-                    .Case("/sof", is_contained(I->flags(), "+sof"))
-                    .Case("/el", is_contained(I->flags(), "-sof"))
-                    .Case("/sof/el", is_contained(I->flags(), "+sof"))
+                    .Case("", is_contained(I->tags(), "-sof"))
+                    .Case("/sof", is_contained(I->tags(), "+sof"))
+                    .Case("/el", is_contained(I->tags(), "-sof"))
+                    .Case("/sof/el", is_contained(I->tags(), "+sof"))
                     .Default(false))
         << "Multilib " << *I << " didn't have the appropriate {+,-}sof flag";
     ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
-                    .Case("", is_contained(I->flags(), "-EL"))
-                    .Case("/sof", is_contained(I->flags(), "-EL"))
-                    .Case("/el", is_contained(I->flags(), "+EL"))
-                    .Case("/sof/el", is_contained(I->flags(), "+EL"))
+                    .Case("", is_contained(I->tags(), "-EL"))
+                    .Case("/sof", is_contained(I->tags(), "-EL"))
+                    .Case("/el", is_contained(I->tags(), "+EL"))
+                    .Case("/sof/el", is_contained(I->tags(), "+EL"))
                     .Default(false))
         << "Multilib " << *I << " didn't have the appropriate {+,-}EL flag";
   }
 }
 
 TEST(MultilibBuilderTest, SetRegexFilter) {
   MultilibSetBuilder MB;
   MB.Maybe(MultilibBuilder("one"))
TEST(MultilibBuilderTest, SetFilterObject) {
   }
 }
 
 TEST(MultilibBuilderTest, SetSelection1) {
   MultilibSet MS1 = MultilibSetBuilder()
                         .Maybe(MultilibBuilder("64").flag("+m64"))
                         .makeMultilibSet();
 
-  Multilib::flag_set FlagM64 = {"+m64"};
+  Multilib::tag_set FlagM64 = {"+m64"};
   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";
 
-  Multilib::flag_set FlagNoM64 = {"-m64"};
+  Multilib::tag_set FlagNoM64 = {"-m64"};
   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";
 }
 
 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::flag_set Flags;
+    Multilib::tag_set Flags;
     if (IsEL)
       Flags.insert("+EL");
     else
       Flags.insert("-EL");
 
     if (IsSF)
       Flags.insert("+SF");
     else

clang/unittests/Driver/MultilibTest.cpp

 TEST(MultilibTest, OpEqReflexivity2) {
   ASSERT_TRUE(Multilib() == Multilib())
       << "Separately constructed default multilibs are not equal";
 }
 
 TEST(MultilibTest, OpEqReflexivity3) {
   Multilib M1({}, {}, {}, {"+foo"});
   Multilib M2({}, {}, {}, {"+foo"});
-  ASSERT_TRUE(M1 == M2) << "Multilibs with the same flag should be the same";
+  ASSERT_TRUE(M1 == M2) << "Multilibs with the same tag should be the same";
 }
 
 TEST(MultilibTest, OpEqInequivalence1) {
   Multilib M1({}, {}, {}, {"+foo"});
   Multilib M2({}, {}, {}, {"-foo"});
-  ASSERT_FALSE(M1 == M2) << "Multilibs with conflicting flags are not the same";
+  ASSERT_FALSE(M1 == M2) << "Multilibs with conflicting tags are not the same";
   ASSERT_FALSE(M2 == M1)
-      << "Multilibs with conflicting flags are not the same (commuted)";
+      << "Multilibs with conflicting tags are not the same (commuted)";
 }
 
 TEST(MultilibTest, OpEqInequivalence2) {
   Multilib M1;
   Multilib M2({}, {}, {}, {"+foo"});
-  ASSERT_FALSE(M1 == M2) << "Flags make Multilibs different";
+  ASSERT_FALSE(M1 == M2) << "Tags make Multilibs different";
 }
 
 TEST(MultilibTest, OpEqEquivalence2) {
   Multilib M1("/64");
   Multilib M2("/64");
   ASSERT_TRUE(M1 == M2)
       << "Constructor argument must match Multilib::gccSuffix()";
   ASSERT_TRUE(M2 == M1)
TEST(MultilibTest, Construction2) {
   ASSERT_TRUE(M1 == M3)
       << "Default arguments to Multilib constructor broken (second argument)";
   ASSERT_TRUE(M1 == M4)
       << "Default arguments to Multilib constructor broken (third argument)";
 }
 
 TEST(MultilibTest, Construction3) {
   Multilib M({}, {}, {}, {"+f1", "+f2", "-f3"});
-  for (Multilib::flag_set::const_iterator I = M.flags().begin(),
-                                          E = M.flags().end();
+  for (Multilib::tag_set::const_iterator I = M.tags().begin(),
+                                         E = M.tags().end();
        I != E; ++I) {
     ASSERT_TRUE(llvm::StringSwitch<bool>(*I)
                     .Cases("+f1", "+f2", "-f3", true)
                     .Default(false));
   }
 }
 
 TEST(MultilibTest, SetPushback) {
TEST(MultilibTest, SetPushback) {
   }
 }
 
 TEST(MultilibTest, SetPriority) {
   MultilibSet MS({
       Multilib("/foo", {}, {}, {"+foo"}),
       Multilib("/bar", {}, {}, {"+bar"}),
   });
-  Multilib::flag_set Flags1 = {"+foo", "-bar"};
+  Multilib::tag_set Tags1 = {"+foo", "-bar"};
   Multilib Selection1;
-  ASSERT_TRUE(MS.select(Flags1, Selection1))
-      << "Flag set was {\"+foo\"}, but selection not found";
+  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";
 
-  Multilib::flag_set Flags2 = {"+foo", "+bar"};
+  Multilib::tag_set Tags2 = {"+foo", "+bar"};
   Multilib Selection2;
-  ASSERT_TRUE(MS.select(Flags2, Selection2))
-      << "Flag set was {\"+bar\"}, but selection not found";
+  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";
 }
 
 TEST(MultilibTest, SelectMultiple) {
   MultilibSet MS({
       Multilib("/a", {}, {}, {"x"}),
       Multilib("/b", {}, {}, {"y"}),