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 llvm::erase_if(Ms, F); 303 } 304 305 raw_ostream &clang::driver::operator<<(raw_ostream &OS, const MultilibSet &MS) { 306 MS.print(OS); 307 return OS; 308 } 309