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 "llvm/ADT/SmallString.h"
12#include "llvm/ADT/StringMap.h"
13#include "llvm/ADT/StringRef.h"
14#include "llvm/ADT/StringSet.h"
15#include "llvm/Support/Compiler.h"
16#include "llvm/Support/ErrorHandling.h"
17#include "llvm/Support/Path.h"
18#include "llvm/Support/Regex.h"
19#include "llvm/Support/raw_ostream.h"
20#include <algorithm>
21#include <cassert>
22#include <string>
23
24using namespace clang;
25using namespace driver;
26using namespace llvm::sys;
27
28/// normalize Segment to "/foo/bar" or "".
29static void normalizePathSegment(std::string &Segment) {
30  StringRef seg = Segment;
31
32  // Prune trailing "/" or "./"
33  while (true) {
34    StringRef last = path::filename(seg);
35    if (last != ".")
36      break;
37    seg = path::parent_path(seg);
38  }
39
40  if (seg.empty() || seg == "/") {
41    Segment.clear();
42    return;
43  }
44
45  // Add leading '/'
46  if (seg.front() != '/') {
47    Segment = "/" + seg.str();
48  } else {
49    Segment = seg;
50  }
51}
52
53Multilib::Multilib(StringRef GCCSuffix, StringRef OSSuffix,
54                   StringRef IncludeSuffix, int Priority)
55    : GCCSuffix(GCCSuffix), OSSuffix(OSSuffix), IncludeSuffix(IncludeSuffix),
56      Priority(Priority) {
57  normalizePathSegment(this->GCCSuffix);
58  normalizePathSegment(this->OSSuffix);
59  normalizePathSegment(this->IncludeSuffix);
60}
61
62Multilib &Multilib::gccSuffix(StringRef S) {
63  GCCSuffix = S;
64  normalizePathSegment(GCCSuffix);
65  return *this;
66}
67
68Multilib &Multilib::osSuffix(StringRef S) {
69  OSSuffix = S;
70  normalizePathSegment(OSSuffix);
71  return *this;
72}
73
74Multilib &Multilib::includeSuffix(StringRef S) {
75  IncludeSuffix = S;
76  normalizePathSegment(IncludeSuffix);
77  return *this;
78}
79
80LLVM_DUMP_METHOD void Multilib::dump() const {
81  print(llvm::errs());
82}
83
84void Multilib::print(raw_ostream &OS) const {
85  assert(GCCSuffix.empty() || (StringRef(GCCSuffix).front() == '/'));
86  if (GCCSuffix.empty())
87    OS << ".";
88  else {
89    OS << StringRef(GCCSuffix).drop_front();
90  }
91  OS << ";";
92  for (StringRef Flag : Flags) {
93    if (Flag.front() == '+')
94      OS << "@" << Flag.substr(1);
95  }
96}
97
98bool Multilib::isValid() const {
99  llvm::StringMap<int> FlagSet;
100  for (unsigned I = 0, N = Flags.size(); I != N; ++I) {
101    StringRef Flag(Flags[I]);
102    llvm::StringMap<int>::iterator SI = FlagSet.find(Flag.substr(1));
103
104    assert(StringRef(Flag).front() == '+' || StringRef(Flag).front() == '-');
105
106    if (SI == FlagSet.end())
107      FlagSet[Flag.substr(1)] = I;
108    else if (Flags[I] != Flags[SI->getValue()])
109      return false;
110  }
111  return true;
112}
113
114bool Multilib::operator==(const Multilib &Other) const {
115  // Check whether the flags sets match
116  // allowing for the match to be order invariant
117  llvm::StringSet<> MyFlags;
118  for (const auto &Flag : Flags)
119    MyFlags.insert(Flag);
120
121  for (const auto &Flag : Other.Flags)
122    if (MyFlags.find(Flag) == MyFlags.end())
123      return false;
124
125  if (osSuffix() != Other.osSuffix())
126    return false;
127
128  if (gccSuffix() != Other.gccSuffix())
129    return false;
130
131  if (includeSuffix() != Other.includeSuffix())
132    return false;
133
134  return true;
135}
136
137raw_ostream &clang::driver::operator<<(raw_ostream &OS, const Multilib &M) {
138  M.print(OS);
139  return OS;
140}
141
142MultilibSet &MultilibSet::Maybe(const Multilib &M) {
143  Multilib Opposite;
144  // Negate any '+' flags
145  for (StringRef Flag : M.flags()) {
146    if (Flag.front() == '+')
147      Opposite.flags().push_back(("-" + Flag.substr(1)).str());
148  }
149  return Either(M, Opposite);
150}
151
152MultilibSet &MultilibSet::Either(const Multilib &M1, const Multilib &M2) {
153  return Either({M1, M2});
154}
155
156MultilibSet &MultilibSet::Either(const Multilib &M1, const Multilib &M2,
157                                 const Multilib &M3) {
158  return Either({M1, M2, M3});
159}
160
161MultilibSet &MultilibSet::Either(const Multilib &M1, const Multilib &M2,
162                                 const Multilib &M3, const Multilib &M4) {
163  return Either({M1, M2, M3, M4});
164}
165
166MultilibSet &MultilibSet::Either(const Multilib &M1, const Multilib &M2,
167                                 const Multilib &M3, const Multilib &M4,
168                                 const Multilib &M5) {
169  return Either({M1, M2, M3, M4, M5});
170}
171
172static Multilib compose(const Multilib &Base, const Multilib &New) {
173  SmallString<128> GCCSuffix;
174  llvm::sys::path::append(GCCSuffix, "/", Base.gccSuffix(), New.gccSuffix());
175  SmallString<128> OSSuffix;
176  llvm::sys::path::append(OSSuffix, "/", Base.osSuffix(), New.osSuffix());
177  SmallString<128> IncludeSuffix;
178  llvm::sys::path::append(IncludeSuffix, "/", Base.includeSuffix(),
179                          New.includeSuffix());
180
181  Multilib Composed(GCCSuffix, OSSuffix, IncludeSuffix);
182
183  Multilib::flags_list &Flags = Composed.flags();
184
185  Flags.insert(Flags.end(), Base.flags().begin(), Base.flags().end());
186  Flags.insert(Flags.end(), New.flags().begin(), New.flags().end());
187
188  return Composed;
189}
190
191MultilibSet &MultilibSet::Either(ArrayRef<Multilib> MultilibSegments) {
192  multilib_list Composed;
193
194  if (Multilibs.empty())
195    Multilibs.insert(Multilibs.end(), MultilibSegments.begin(),
196                     MultilibSegments.end());
197  else {
198    for (const auto &New : MultilibSegments) {
199      for (const auto &Base : *this) {
200        Multilib MO = compose(Base, New);
201        if (MO.isValid())
202          Composed.push_back(MO);
203      }
204    }
205
206    Multilibs = Composed;
207  }
208
209  return *this;
210}
211
212MultilibSet &MultilibSet::FilterOut(FilterCallback F) {
213  filterInPlace(F, Multilibs);
214  return *this;
215}
216
217MultilibSet &MultilibSet::FilterOut(const char *Regex) {
218  llvm::Regex R(Regex);
219#ifndef NDEBUG
220  std::string Error;
221  if (!R.isValid(Error)) {
222    llvm::errs() << Error;
223    llvm_unreachable("Invalid regex!");
224  }
225#endif
226
227  filterInPlace([&R](const Multilib &M) { return R.match(M.gccSuffix()); },
228                Multilibs);
229  return *this;
230}
231
232void MultilibSet::push_back(const Multilib &M) { Multilibs.push_back(M); }
233
234void MultilibSet::combineWith(const MultilibSet &Other) {
235  Multilibs.insert(Multilibs.end(), Other.begin(), Other.end());
236}
237
238static bool isFlagEnabled(StringRef Flag) {
239  char Indicator = Flag.front();
240  assert(Indicator == '+' || Indicator == '-');
241  return Indicator == '+';
242}
243
244bool MultilibSet::select(const Multilib::flags_list &Flags, Multilib &M) const {
245  llvm::StringMap<bool> FlagSet;
246
247  // Stuff all of the flags into the FlagSet such that a true mappend indicates
248  // the flag was enabled, and a false mappend indicates the flag was disabled.
249  for (StringRef Flag : Flags)
250    FlagSet[Flag.substr(1)] = isFlagEnabled(Flag);
251
252  multilib_list Filtered = filterCopy([&FlagSet](const Multilib &M) {
253    for (StringRef Flag : M.flags()) {
254      llvm::StringMap<bool>::const_iterator SI = FlagSet.find(Flag.substr(1));
255      if (SI != FlagSet.end())
256        if (SI->getValue() != isFlagEnabled(Flag))
257          return true;
258    }
259    return false;
260  }, Multilibs);
261
262  if (Filtered.empty())
263    return false;
264  if (Filtered.size() == 1) {
265    M = Filtered[0];
266    return true;
267  }
268
269  // Sort multilibs by priority and select the one with the highest priority.
270  llvm::sort(Filtered.begin(), Filtered.end(),
271             [](const Multilib &a, const Multilib &b) -> bool {
272               return a.priority() > b.priority();
273             });
274
275  if (Filtered[0].priority() > Filtered[1].priority()) {
276    M = Filtered[0];
277    return true;
278  }
279
280  // TODO: We should consider returning llvm::Error rather than aborting.
281  assert(false && "More than one multilib with the same priority");
282  return false;
283}
284
285LLVM_DUMP_METHOD void MultilibSet::dump() const {
286  print(llvm::errs());
287}
288
289void MultilibSet::print(raw_ostream &OS) const {
290  for (const auto &M : *this)
291    OS << M << "\n";
292}
293
294MultilibSet::multilib_list MultilibSet::filterCopy(FilterCallback F,
295                                                   const multilib_list &Ms) {
296  multilib_list Copy(Ms);
297  filterInPlace(F, Copy);
298  return Copy;
299}
300
301void MultilibSet::filterInPlace(FilterCallback F, multilib_list &Ms) {
302  Ms.erase(std::remove_if(Ms.begin(), Ms.end(), F), Ms.end());
303}
304
305raw_ostream &clang::driver::operator<<(raw_ostream &OS, const MultilibSet &MS) {
306  MS.print(OS);
307  return OS;
308}
309