clang/lib/Driver/Multilib.cpp

   1 //===- Multilib.cpp - Multilib Implementation -----------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "clang/Driver/Multilib.h"
  10 #include "clang/Basic/LLVM.h"
  11 #include "clang/Basic/Version.h"
  12 #include "llvm/ADT/DenseSet.h"
  13 #include "llvm/ADT/SmallString.h"
  14 #include "llvm/ADT/StringRef.h"
  15 #include "llvm/Support/Compiler.h"
  16 #include "llvm/Support/Error.h"
  17 #include "llvm/Support/ErrorHandling.h"
  18 #include "llvm/Support/Path.h"
  19 #include "llvm/Support/Regex.h"
  20 #include "llvm/Support/VersionTuple.h"
  21 #include "llvm/Support/YAMLParser.h"
  22 #include "llvm/Support/YAMLTraits.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 #include <algorithm>
  25 #include <cassert>
  26 #include <string>
  27
  28 using namespace clang;
  29 using namespace driver;
  30 using namespace llvm::sys;
  31
  32 Multilib::Multilib(StringRef GCCSuffix, StringRef OSSuffix,
  33                    StringRef IncludeSuffix, const flags_list &Flags,
  34                    StringRef ExclusiveGroup)
  35     : GCCSuffix(GCCSuffix), OSSuffix(OSSuffix), IncludeSuffix(IncludeSuffix),
  36       Flags(Flags), ExclusiveGroup(ExclusiveGroup) {
  37   assert(GCCSuffix.empty() ||
  38          (StringRef(GCCSuffix).front() == '/' && GCCSuffix.size() > 1));
  39   assert(OSSuffix.empty() ||
  40          (StringRef(OSSuffix).front() == '/' && OSSuffix.size() > 1));
  41   assert(IncludeSuffix.empty() ||
  42          (StringRef(IncludeSuffix).front() == '/' && IncludeSuffix.size() > 1));
  43 }
  44
  45 LLVM_DUMP_METHOD void Multilib::dump() const {
  46   print(llvm::errs());
  47 }
  48
  49 void Multilib::print(raw_ostream &OS) const {
  50   if (GCCSuffix.empty())
  51     OS << ".";
  52   else {
  53     OS << StringRef(GCCSuffix).drop_front();
  54   }
  55   OS << ";";
  56   for (StringRef Flag : Flags) {
  57     if (Flag.front() == '-')
  58       OS << "@" << Flag.substr(1);
  59   }
  60 }
  61
  62 bool Multilib::operator==(const Multilib &Other) const {
  63   // Check whether the flags sets match
  64   // allowing for the match to be order invariant
  65   llvm::StringSet<> MyFlags;
  66   for (const auto &Flag : Flags)
  67     MyFlags.insert(Flag);
  68
  69   for (const auto &Flag : Other.Flags)
  70     if (!MyFlags.contains(Flag))
  71       return false;
  72
  73   if (osSuffix() != Other.osSuffix())
  74     return false;
  75
  76   if (gccSuffix() != Other.gccSuffix())
  77     return false;
  78
  79   if (includeSuffix() != Other.includeSuffix())
  80     return false;
  81
  82   return true;
  83 }
  84
  85 raw_ostream &clang::driver::operator<<(raw_ostream &OS, const Multilib &M) {
  86   M.print(OS);
  87   return OS;
  88 }
  89
  90 MultilibSet &MultilibSet::FilterOut(FilterCallback F) {
  91   llvm::erase_if(Multilibs, F);
  92   return *this;
  93 }
  94
  95 void MultilibSet::push_back(const Multilib &M) { Multilibs.push_back(M); }
  96
  97 bool MultilibSet::select(const Multilib::flags_list &Flags,
  98                          llvm::SmallVectorImpl<Multilib> &Selected) const {
  99   llvm::StringSet<> FlagSet(expandFlags(Flags));
 100   Selected.clear();
 101
 102   // Decide which multilibs we're going to select at all.
 103   llvm::DenseSet<StringRef> ExclusiveGroupsSelected;
 104   for (const Multilib &M : llvm::reverse(Multilibs)) {
 105     // If this multilib doesn't match all our flags, don't select it.
 106     if (!llvm::all_of(M.flags(), [&FlagSet](const std::string &F) {
 107           return FlagSet.contains(F);
 108         }))
 109       continue;
 110
 111     const std::string &group = M.exclusiveGroup();
 112     if (!group.empty()) {
 113       // If this multilib has the same ExclusiveGroup as one we've already
 114       // selected, skip it. We're iterating in reverse order, so the group
 115       // member we've selected already is preferred.
 116       //
 117       // Otherwise, add the group name to the set of groups we've already
 118       // selected a member of.
 119       auto [It, Inserted] = ExclusiveGroupsSelected.insert(group);
 120       if (!Inserted)
 121         continue;
 122     }
 123
 124     // Select this multilib.
 125     Selected.push_back(M);
 126   }
 127
 128   // We iterated in reverse order, so now put Selected back the right way
 129   // round.
 130   std::reverse(Selected.begin(), Selected.end());
 131
 132   return !Selected.empty();
 133 }
 134
 135 llvm::StringSet<>
 136 MultilibSet::expandFlags(const Multilib::flags_list &InFlags) const {
 137   llvm::StringSet<> Result;
 138   for (const auto &F : InFlags)
 139     Result.insert(F);
 140   for (const FlagMatcher &M : FlagMatchers) {
 141     std::string RegexString(M.Match);
 142
 143     // Make the regular expression match the whole string.
 144     if (!StringRef(M.Match).starts_with("^"))
 145       RegexString.insert(RegexString.begin(), '^');
 146     if (!StringRef(M.Match).ends_with("$"))
 147       RegexString.push_back('$');
 148
 149     const llvm::Regex Regex(RegexString);
 150     assert(Regex.isValid());
 151     if (llvm::any_of(InFlags,
 152                      [&Regex](StringRef F) { return Regex.match(F); })) {
 153       Result.insert(M.Flags.begin(), M.Flags.end());
 154     }
 155   }
 156   return Result;
 157 }
 158
 159 namespace {
 160
 161 // When updating this also update MULTILIB_VERSION in MultilibTest.cpp
 162 static const VersionTuple MultilibVersionCurrent(1, 0);
 163
 164 struct MultilibSerialization {
 165   std::string Dir;
 166   std::vector<std::string> Flags;
 167   std::string Group;
 168 };
 169
 170 enum class MultilibGroupType {
 171   /*
 172    * The only group type currently supported is 'Exclusive', which indicates a
 173    * group of multilibs of which at most one may be selected.
 174    */
 175   Exclusive,
 176
 177   /*
 178    * Future possibility: a second group type indicating a set of library
 179    * directories that are mutually _dependent_ rather than mutually exclusive:
 180    * if you include one you must include them all.
 181    *
 182    * It might also be useful to allow groups to be members of other groups, so
 183    * that a mutually exclusive group could contain a mutually dependent set of
 184    * library directories, or vice versa.
 185    *
 186    * These additional features would need changes in the implementation, but
 187    * the YAML schema is set up so they can be added without requiring changes
 188    * in existing users' multilib.yaml files.
 189    */
 190 };
 191
 192 struct MultilibGroupSerialization {
 193   std::string Name;
 194   MultilibGroupType Type;
 195 };
 196
 197 struct MultilibSetSerialization {
 198   llvm::VersionTuple MultilibVersion;
 199   std::vector<MultilibGroupSerialization> Groups;
 200   std::vector<MultilibSerialization> Multilibs;
 201   std::vector<MultilibSet::FlagMatcher> FlagMatchers;
 202 };
 203
 204 } // end anonymous namespace
 205
 206 template <> struct llvm::yaml::MappingTraits<MultilibSerialization> {
 207   static void mapping(llvm::yaml::IO &io, MultilibSerialization &V) {
 208     io.mapRequired("Dir", V.Dir);
 209     io.mapRequired("Flags", V.Flags);
 210     io.mapOptional("Group", V.Group);
 211   }
 212   static std::string validate(IO &io, MultilibSerialization &V) {
 213     if (StringRef(V.Dir).starts_with("/"))
 214       return "paths must be relative but \"" + V.Dir + "\" starts with \"/\"";
 215     return std::string{};
 216   }
 217 };
 218
 219 template <> struct llvm::yaml::ScalarEnumerationTraits<MultilibGroupType> {
 220   static void enumeration(IO &io, MultilibGroupType &Val) {
 221     io.enumCase(Val, "Exclusive", MultilibGroupType::Exclusive);
 222   }
 223 };
 224
 225 template <> struct llvm::yaml::MappingTraits<MultilibGroupSerialization> {
 226   static void mapping(llvm::yaml::IO &io, MultilibGroupSerialization &V) {
 227     io.mapRequired("Name", V.Name);
 228     io.mapRequired("Type", V.Type);
 229   }
 230 };
 231
 232 template <> struct llvm::yaml::MappingTraits<MultilibSet::FlagMatcher> {
 233   static void mapping(llvm::yaml::IO &io, MultilibSet::FlagMatcher &M) {
 234     io.mapRequired("Match", M.Match);
 235     io.mapRequired("Flags", M.Flags);
 236   }
 237   static std::string validate(IO &io, MultilibSet::FlagMatcher &M) {
 238     llvm::Regex Regex(M.Match);
 239     std::string RegexError;
 240     if (!Regex.isValid(RegexError))
 241       return RegexError;
 242     if (M.Flags.empty())
 243       return "value required for 'Flags'";
 244     return std::string{};
 245   }
 246 };
 247
 248 template <> struct llvm::yaml::MappingTraits<MultilibSetSerialization> {
 249   static void mapping(llvm::yaml::IO &io, MultilibSetSerialization &M) {
 250     io.mapRequired("MultilibVersion", M.MultilibVersion);
 251     io.mapRequired("Variants", M.Multilibs);
 252     io.mapOptional("Groups", M.Groups);
 253     io.mapOptional("Mappings", M.FlagMatchers);
 254   }
 255   static std::string validate(IO &io, MultilibSetSerialization &M) {
 256     if (M.MultilibVersion.empty())
 257       return "missing required key 'MultilibVersion'";
 258     if (M.MultilibVersion.getMajor() != MultilibVersionCurrent.getMajor())
 259       return "multilib version " + M.MultilibVersion.getAsString() +
 260              " is unsupported";
 261     if (M.MultilibVersion.getMinor() > MultilibVersionCurrent.getMinor())
 262       return "multilib version " + M.MultilibVersion.getAsString() +
 263              " is unsupported";
 264     for (const MultilibSerialization &Lib : M.Multilibs) {
 265       if (!Lib.Group.empty()) {
 266         bool Found = false;
 267         for (const MultilibGroupSerialization &Group : M.Groups)
 268           if (Group.Name == Lib.Group) {
 269             Found = true;
 270             break;
 271           }
 272         if (!Found)
 273           return "multilib \"" + Lib.Dir +
 274                  "\" specifies undefined group name \"" + Lib.Group + "\"";
 275       }
 276     }
 277     return std::string{};
 278   }
 279 };
 280
 281 LLVM_YAML_IS_SEQUENCE_VECTOR(MultilibSerialization)
 282 LLVM_YAML_IS_SEQUENCE_VECTOR(MultilibGroupSerialization)
 283 LLVM_YAML_IS_SEQUENCE_VECTOR(MultilibSet::FlagMatcher)
 284
 285 llvm::ErrorOr<MultilibSet>
 286 MultilibSet::parseYaml(llvm::MemoryBufferRef Input,
 287                        llvm::SourceMgr::DiagHandlerTy DiagHandler,
 288                        void *DiagHandlerCtxt) {
 289   MultilibSetSerialization MS;
 290   llvm::yaml::Input YamlInput(Input, nullptr, DiagHandler, DiagHandlerCtxt);
 291   YamlInput >> MS;
 292   if (YamlInput.error())
 293     return YamlInput.error();
 294
 295   multilib_list Multilibs;
 296   Multilibs.reserve(MS.Multilibs.size());
 297   for (const auto &M : MS.Multilibs) {
 298     std::string Dir;
 299     if (M.Dir != ".")
 300       Dir = "/" + M.Dir;
 301     // We transfer M.Group straight into the ExclusiveGroup parameter for the
 302     // Multilib constructor. If we later support more than one type of group,
 303     // we'll have to look up the group name in MS.Groups, check its type, and
 304     // decide what to do here.
 305     Multilibs.emplace_back(Dir, Dir, Dir, M.Flags, M.Group);
 306   }
 307
 308   return MultilibSet(std::move(Multilibs), std::move(MS.FlagMatchers));
 309 }
 310
 311 LLVM_DUMP_METHOD void MultilibSet::dump() const {
 312   print(llvm::errs());
 313 }
 314
 315 void MultilibSet::print(raw_ostream &OS) const {
 316   for (const auto &M : *this)
 317     OS << M << "\n";
 318 }
 319
 320 raw_ostream &clang::driver::operator<<(raw_ostream &OS, const MultilibSet &MS) {
 321   MS.print(OS);
 322   return OS;
 323 }