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