|
150
|
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
|
|
|
24 using namespace clang;
|
|
|
25 using namespace driver;
|
|
|
26 using namespace llvm::sys;
|
|
|
27
|
|
|
28 /// normalize Segment to "/foo/bar" or "".
|
|
|
29 static 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 = std::string(seg);
|
|
|
50 }
|
|
|
51 }
|
|
|
52
|
|
|
53 Multilib::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
|
|
|
62 Multilib &Multilib::gccSuffix(StringRef S) {
|
|
|
63 GCCSuffix = std::string(S);
|
|
|
64 normalizePathSegment(GCCSuffix);
|
|
|
65 return *this;
|
|
|
66 }
|
|
|
67
|
|
|
68 Multilib &Multilib::osSuffix(StringRef S) {
|
|
|
69 OSSuffix = std::string(S);
|
|
|
70 normalizePathSegment(OSSuffix);
|
|
|
71 return *this;
|
|
|
72 }
|
|
|
73
|
|
|
74 Multilib &Multilib::includeSuffix(StringRef S) {
|
|
|
75 IncludeSuffix = std::string(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
|
|
|
142 MultilibSet &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
|
|
|
152 MultilibSet &MultilibSet::Either(const Multilib &M1, const Multilib &M2) {
|
|
|
153 return Either({M1, M2});
|
|
|
154 }
|
|
|
155
|
|
|
156 MultilibSet &MultilibSet::Either(const Multilib &M1, const Multilib &M2,
|
|
|
157 const Multilib &M3) {
|
|
|
158 return Either({M1, M2, M3});
|
|
|
159 }
|
|
|
160
|
|
|
161 MultilibSet &MultilibSet::Either(const Multilib &M1, const Multilib &M2,
|
|
|
162 const Multilib &M3, const Multilib &M4) {
|
|
|
163 return Either({M1, M2, M3, M4});
|
|
|
164 }
|
|
|
165
|
|
|
166 MultilibSet &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
|
|
|
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
|
|
|
191 MultilibSet &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
|
|
|
212 MultilibSet &MultilibSet::FilterOut(FilterCallback F) {
|
|
|
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
|
|
|
234 void MultilibSet::combineWith(const MultilibSet &Other) {
|
|
|
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 // 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
|
|
|
285 LLVM_DUMP_METHOD void MultilibSet::dump() const {
|
|
|
286 print(llvm::errs());
|
|
|
287 }
|
|
|
288
|
|
|
289 void MultilibSet::print(raw_ostream &OS) const {
|
|
|
290 for (const auto &M : *this)
|
|
|
291 OS << M << "\n";
|
|
|
292 }
|
|
|
293
|
|
|
294 MultilibSet::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
|
|
|
301 void MultilibSet::filterInPlace(FilterCallback F, multilib_list &Ms) {
|
|
|
302 Ms.erase(std::remove_if(Ms.begin(), Ms.end(), F), Ms.end());
|
|
|
303 }
|
|
|
304
|
|
|
305 raw_ostream &clang::driver::operator<<(raw_ostream &OS, const MultilibSet &MS) {
|
|
|
306 MS.print(OS);
|
|
|
307 return OS;
|
|
|
308 }
|
