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