clang  8.0.0svn
Multilib.cpp
Go to the documentation of this file.
1 //===- Multilib.cpp - Multilib Implementation -----------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "clang/Driver/Multilib.h"
11 #include "clang/Basic/LLVM.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/StringMap.h"
14 #include "llvm/ADT/StringRef.h"
15 #include "llvm/ADT/StringSet.h"
16 #include "llvm/Support/Compiler.h"
17 #include "llvm/Support/ErrorHandling.h"
18 #include "llvm/Support/Path.h"
19 #include "llvm/Support/Regex.h"
20 #include "llvm/Support/raw_ostream.h"
21 #include <algorithm>
22 #include <cassert>
23 #include <string>
24 
25 using namespace clang;
26 using namespace driver;
27 using namespace llvm::sys;
28 
29 /// normalize Segment to "/foo/bar" or "".
30 static void normalizePathSegment(std::string &Segment) {
31  StringRef seg = Segment;
32 
33  // Prune trailing "/" or "./"
34  while (true) {
35  StringRef last = path::filename(seg);
36  if (last != ".")
37  break;
38  seg = path::parent_path(seg);
39  }
40 
41  if (seg.empty() || seg == "/") {
42  Segment.clear();
43  return;
44  }
45 
46  // Add leading '/'
47  if (seg.front() != '/') {
48  Segment = "/" + seg.str();
49  } else {
50  Segment = seg;
51  }
52 }
53 
54 Multilib::Multilib(StringRef GCCSuffix, StringRef OSSuffix,
55  StringRef IncludeSuffix)
56  : GCCSuffix(GCCSuffix), OSSuffix(OSSuffix), IncludeSuffix(IncludeSuffix) {
57  normalizePathSegment(this->GCCSuffix);
58  normalizePathSegment(this->OSSuffix);
59  normalizePathSegment(this->IncludeSuffix);
60 }
61 
63  GCCSuffix = S;
64  normalizePathSegment(GCCSuffix);
65  return *this;
66 }
67 
69  OSSuffix = S;
70  normalizePathSegment(OSSuffix);
71  return *this;
72 }
73 
75  IncludeSuffix = S;
76  normalizePathSegment(IncludeSuffix);
77  return *this;
78 }
79 
80 LLVM_DUMP_METHOD void Multilib::dump() const {
81  print(llvm::errs());
82 }
83 
84 void 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 
98 bool 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 
114 bool 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 
137 raw_ostream &clang::driver::operator<<(raw_ostream &OS, const Multilib &M) {
138  M.print(OS);
139  return OS;
140 }
141 
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 
153  return Either({M1, M2});
154 }
155 
157  const Multilib &M3) {
158  return Either({M1, M2, M3});
159 }
160 
162  const Multilib &M3, const Multilib &M4) {
163  return Either({M1, M2, M3, M4});
164 }
165 
167  const Multilib &M3, const Multilib &M4,
168  const Multilib &M5) {
169  return Either({M1, M2, M3, M4, M5});
170 }
171 
172 static 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 
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 
213  filterInPlace(F, Multilibs);
214  return *this;
215 }
216 
217 MultilibSet &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 
232 void MultilibSet::push_back(const Multilib &M) { Multilibs.push_back(M); }
233 
235  Multilibs.insert(Multilibs.end(), Other.begin(), Other.end());
236 }
237 
238 static bool isFlagEnabled(StringRef Flag) {
239  char Indicator = Flag.front();
240  assert(Indicator == '+' || Indicator == '-');
241  return Indicator == '+';
242 }
243 
244 bool 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  // TODO: pick the "best" multlib when more than one is suitable
270  assert(false);
271  return false;
272 }
273 
274 LLVM_DUMP_METHOD void MultilibSet::dump() const {
275  print(llvm::errs());
276 }
277 
278 void MultilibSet::print(raw_ostream &OS) const {
279  for (const auto &M : *this)
280  OS << M << "\n";
281 }
282 
283 MultilibSet::multilib_list MultilibSet::filterCopy(FilterCallback F,
284  const multilib_list &Ms) {
285  multilib_list Copy(Ms);
286  filterInPlace(F, Copy);
287  return Copy;
288 }
289 
290 void MultilibSet::filterInPlace(FilterCallback F, multilib_list &Ms) {
291  Ms.erase(std::remove_if(Ms.begin(), Ms.end(), F), Ms.end());
292 }
293 
294 raw_ostream &clang::driver::operator<<(raw_ostream &OS, const MultilibSet &MS) {
295  MS.print(OS);
296  return OS;
297 }
MultilibSet & Either(const Multilib &M1, const Multilib &M2)
Add a set of mutually incompatible Multilib segments.
Definition: Multilib.cpp:152
MultilibSet & Maybe(const Multilib &M)
Add an optional Multilib segment.
Definition: Multilib.cpp:142
bool operator==(const Multilib &Other) const
Definition: Multilib.cpp:114
static Multilib compose(const Multilib &Base, const Multilib &New)
Definition: Multilib.cpp:172
std::vector< Multilib > multilib_list
Definition: Multilib.h:112
Multilib(StringRef GCCSuffix={}, StringRef OSSuffix={}, StringRef IncludeSuffix={})
Definition: Multilib.cpp:54
bool select(const Multilib::flags_list &Flags, Multilib &M) const
Pick the best multilib in the set,.
Definition: Multilib.cpp:244
const std::string & includeSuffix() const
Get the include directory suffix.
Definition: Multilib.h:67
raw_ostream & operator<<(raw_ostream &OS, const Multilib &M)
Definition: Multilib.cpp:137
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
Definition: Multilib.h:45
void combineWith(const MultilibSet &MS)
Union this set of multilibs with another.
Definition: Multilib.cpp:234
static void normalizePathSegment(std::string &Segment)
normalize Segment to "/foo/bar" or "".
Definition: Multilib.cpp:30
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
const std::string & osSuffix() const
Get the detected os path suffix for the multi-arch target variant.
Definition: Multilib.h:56
void print(raw_ostream &OS) const
Definition: Multilib.cpp:278
LLVM_DUMP_METHOD void dump() const
Definition: Multilib.cpp:274
std::vector< std::string > flags_list
Definition: Multilib.h:31
void push_back(const Multilib &M)
Add a completed Multilib to the set.
Definition: Multilib.cpp:232
const flags_list & flags() const
Get the flags that indicate or contraindicate this multilib&#39;s use All elements begin with either &#39;+&#39; ...
Definition: Multilib.h:78
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag...
Definition: Multilib.h:29
bool isValid() const
Check whether any of the &#39;against&#39; flags contradict the &#39;for&#39; flags.
Definition: Multilib.cpp:98
void print(raw_ostream &OS) const
print summary of the Multilib
Definition: Multilib.cpp:84
llvm::function_ref< bool(const Multilib &)> FilterCallback
Definition: Multilib.h:117
Dataflow Directional Tag Classes.
MultilibSet & FilterOut(FilterCallback F)
Filter out some subset of the Multilibs using a user defined callback.
Definition: Multilib.cpp:212
static bool isFlagEnabled(StringRef Flag)
Definition: Multilib.cpp:238
LLVM_DUMP_METHOD void dump() const
Definition: Multilib.cpp:80