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 "".
normalizePathSegment(std::string & Segment)35 static void normalizePathSegment(std::string &Segment) {
36 StringRef seg = Segment;
37
38 // Prune trailing "/" or "./"
39 while (1) {
40 StringRef last = *--path::end(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
Multilib(StringRef GCCSuffix,StringRef OSSuffix,StringRef IncludeSuffix)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
gccSuffix(StringRef S)67 Multilib &Multilib::gccSuffix(StringRef S) {
68 GCCSuffix = S;
69 normalizePathSegment(GCCSuffix);
70 return *this;
71 }
72
osSuffix(StringRef S)73 Multilib &Multilib::osSuffix(StringRef S) {
74 OSSuffix = S;
75 normalizePathSegment(OSSuffix);
76 return *this;
77 }
78
includeSuffix(StringRef S)79 Multilib &Multilib::includeSuffix(StringRef S) {
80 IncludeSuffix = S;
81 normalizePathSegment(IncludeSuffix);
82 return *this;
83 }
84
print(raw_ostream & OS) const85 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
isValid() const99 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
operator ==(const Multilib & Other) const115 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
operator <<(raw_ostream & OS,const Multilib & M)138 raw_ostream &clang::driver::operator<<(raw_ostream &OS, const Multilib &M) {
139 M.print(OS);
140 return OS;
141 }
142
Maybe(const Multilib & M)143 MultilibSet &MultilibSet::Maybe(const Multilib &M) {
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
Either(const Multilib & M1,const Multilib & M2)153 MultilibSet &MultilibSet::Either(const Multilib &M1, const Multilib &M2) {
154 std::vector<Multilib> Ms;
155 Ms.push_back(M1);
156 Ms.push_back(M2);
157 return Either(Ms);
158 }
159
Either(const Multilib & M1,const Multilib & M2,const Multilib & M3)160 MultilibSet &MultilibSet::Either(const Multilib &M1, const Multilib &M2,
161 const Multilib &M3) {
162 std::vector<Multilib> Ms;
163 Ms.push_back(M1);
164 Ms.push_back(M2);
165 Ms.push_back(M3);
166 return Either(Ms);
167 }
168
Either(const Multilib & M1,const Multilib & M2,const Multilib & M3,const Multilib & M4)169 MultilibSet &MultilibSet::Either(const Multilib &M1, const Multilib &M2,
170 const Multilib &M3, const Multilib &M4) {
171 std::vector<Multilib> Ms;
172 Ms.push_back(M1);
173 Ms.push_back(M2);
174 Ms.push_back(M3);
175 Ms.push_back(M4);
176 return Either(Ms);
177 }
178
Either(const Multilib & M1,const Multilib & M2,const Multilib & M3,const Multilib & M4,const Multilib & M5)179 MultilibSet &MultilibSet::Either(const Multilib &M1, const Multilib &M2,
180 const Multilib &M3, const Multilib &M4,
181 const Multilib &M5) {
182 std::vector<Multilib> Ms;
183 Ms.push_back(M1);
184 Ms.push_back(M2);
185 Ms.push_back(M3);
186 Ms.push_back(M4);
187 Ms.push_back(M5);
188 return Either(Ms);
189 }
190
compose(const Multilib & Base,const Multilib & New)191 static Multilib compose(const Multilib &Base, const Multilib &New) {
192 SmallString<128> GCCSuffix;
193 llvm::sys::path::append(GCCSuffix, "/", Base.gccSuffix(), New.gccSuffix());
194 SmallString<128> OSSuffix;
195 llvm::sys::path::append(OSSuffix, "/", Base.osSuffix(), New.osSuffix());
196 SmallString<128> IncludeSuffix;
197 llvm::sys::path::append(IncludeSuffix, "/", Base.includeSuffix(),
198 New.includeSuffix());
199
200 Multilib Composed(GCCSuffix.str(), OSSuffix.str(), IncludeSuffix.str());
201
202 Multilib::flags_list &Flags = Composed.flags();
203
204 Flags.insert(Flags.end(), Base.flags().begin(), Base.flags().end());
205 Flags.insert(Flags.end(), New.flags().begin(), New.flags().end());
206
207 return Composed;
208 }
209
210 MultilibSet &
Either(const std::vector<Multilib> & MultilibSegments)211 MultilibSet::Either(const std::vector<Multilib> &MultilibSegments) {
212 multilib_list Composed;
213
214 if (Multilibs.empty())
215 Multilibs.insert(Multilibs.end(), MultilibSegments.begin(),
216 MultilibSegments.end());
217 else {
218 for (const Multilib &New : MultilibSegments) {
219 for (const Multilib &Base : *this) {
220 Multilib MO = compose(Base, New);
221 if (MO.isValid())
222 Composed.push_back(MO);
223 }
224 }
225
226 Multilibs = Composed;
227 }
228
229 return *this;
230 }
231
FilterOut(const MultilibSet::FilterCallback & F)232 MultilibSet &MultilibSet::FilterOut(const MultilibSet::FilterCallback &F) {
233 filterInPlace(F, Multilibs);
234 return *this;
235 }
236
FilterOut(std::string Regex)237 MultilibSet &MultilibSet::FilterOut(std::string Regex) {
238 class REFilter : public MultilibSet::FilterCallback {
239 mutable llvm::Regex R;
240
241 public:
242 REFilter(std::string Regex) : R(Regex) {}
243 bool operator()(const Multilib &M) const override {
244 std::string Error;
245 if (!R.isValid(Error)) {
246 llvm::errs() << Error;
247 assert(false);
248 return false;
249 }
250 return R.match(M.gccSuffix());
251 }
252 };
253
254 REFilter REF(Regex);
255 filterInPlace(REF, Multilibs);
256 return *this;
257 }
258
push_back(const Multilib & M)259 void MultilibSet::push_back(const Multilib &M) { Multilibs.push_back(M); }
260
combineWith(const MultilibSet & Other)261 void MultilibSet::combineWith(const MultilibSet &Other) {
262 Multilibs.insert(Multilibs.end(), Other.begin(), Other.end());
263 }
264
select(const Multilib::flags_list & Flags,Multilib & M) const265 bool MultilibSet::select(const Multilib::flags_list &Flags, Multilib &M) const {
266 class FilterFlagsMismatch : public MultilibSet::FilterCallback {
267 llvm::StringMap<bool> FlagSet;
268
269 public:
270 FilterFlagsMismatch(const std::vector<std::string> &Flags) {
271 // Stuff all of the flags into the FlagSet such that a true mappend
272 // indicates the flag was enabled, and a false mappend indicates the
273 // flag was disabled
274 for (StringRef Flag : Flags)
275 FlagSet[Flag.substr(1)] = isFlagEnabled(Flag);
276 }
277 bool operator()(const Multilib &M) const override {
278 for (StringRef Flag : M.flags()) {
279 llvm::StringMap<bool>::const_iterator SI = FlagSet.find(Flag.substr(1));
280 if (SI != FlagSet.end())
281 if (SI->getValue() != isFlagEnabled(Flag))
282 return true;
283 }
284 return false;
285 }
286 private:
287 bool isFlagEnabled(StringRef Flag) const {
288 char Indicator = Flag.front();
289 assert(Indicator == '+' || Indicator == '-');
290 return Indicator == '+';
291 }
292 };
293
294 FilterFlagsMismatch FlagsMismatch(Flags);
295
296 multilib_list Filtered = filterCopy(FlagsMismatch, Multilibs);
297
298 if (Filtered.size() == 0) {
299 return false;
300 } else if (Filtered.size() == 1) {
301 M = Filtered[0];
302 return true;
303 }
304
305 // TODO: pick the "best" multlib when more than one is suitable
306 assert(false);
307
308 return false;
309 }
310
print(raw_ostream & OS) const311 void MultilibSet::print(raw_ostream &OS) const {
312 for (const Multilib &M : *this)
313 OS << M << "\n";
314 }
315
316 MultilibSet::multilib_list
filterCopy(const MultilibSet::FilterCallback & F,const multilib_list & Ms)317 MultilibSet::filterCopy(const MultilibSet::FilterCallback &F,
318 const multilib_list &Ms) {
319 multilib_list Copy(Ms);
320 filterInPlace(F, Copy);
321 return Copy;
322 }
323
filterInPlace(const MultilibSet::FilterCallback & F,multilib_list & Ms)324 void MultilibSet::filterInPlace(const MultilibSet::FilterCallback &F,
325 multilib_list &Ms) {
326 Ms.erase(std::remove_if(Ms.begin(), Ms.end(),
327 [&F](const Multilib &M) { return F(M); }),
328 Ms.end());
329 }
330
operator <<(raw_ostream & OS,const MultilibSet & MS)331 raw_ostream &clang::driver::operator<<(raw_ostream &OS, const MultilibSet &MS) {
332 MS.print(OS);
333 return OS;
334 }
335