//===- MultilibBuilder.cpp - MultilibBuilder Implementation -===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #include "clang/Driver/MultilibBuilder.h" #include "ToolChains/CommonArgs.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringMap.h" #include "llvm/Support/Path.h" #include "llvm/Support/Regex.h" #include "llvm/Support/raw_ostream.h" using namespace clang; using namespace driver; /// normalize Segment to "/foo/bar" or "". static void normalizePathSegment(std::string &Segment) { StringRef seg = Segment; // Prune trailing "/" or "./" while (true) { StringRef last = llvm::sys::path::filename(seg); if (last != ".") break; seg = llvm::sys::path::parent_path(seg); } if (seg.empty() || seg == "/") { Segment.clear(); return; } // Add leading '/' if (seg.front() != '/') { Segment = "/" + seg.str(); } else { Segment = std::string(seg); } } MultilibBuilder::MultilibBuilder(StringRef GCC, StringRef OS, StringRef Include) : GCCSuffix(GCC), OSSuffix(OS), IncludeSuffix(Include) { normalizePathSegment(GCCSuffix); normalizePathSegment(OSSuffix); normalizePathSegment(IncludeSuffix); } MultilibBuilder::MultilibBuilder(StringRef Suffix) : MultilibBuilder(Suffix, Suffix, Suffix) {} MultilibBuilder &MultilibBuilder::gccSuffix(StringRef S) { GCCSuffix = std::string(S); normalizePathSegment(GCCSuffix); return *this; } MultilibBuilder &MultilibBuilder::osSuffix(StringRef S) { OSSuffix = std::string(S); normalizePathSegment(OSSuffix); return *this; } MultilibBuilder &MultilibBuilder::includeSuffix(StringRef S) { IncludeSuffix = std::string(S); normalizePathSegment(IncludeSuffix); return *this; } bool MultilibBuilder::isValid() const { llvm::StringMap<int> FlagSet; for (unsigned I = 0, N = Flags.size(); I != N; ++I) { StringRef Flag(Flags[I]); llvm::StringMap<int>::iterator SI = FlagSet.find(Flag.substr(1)); assert(StringRef(Flag).front() == '-' || StringRef(Flag).front() == '!'); if (SI == FlagSet.end()) FlagSet[Flag.substr(1)] = I; else if (Flags[I] != Flags[SI->getValue()]) return false; } return true; } MultilibBuilder &MultilibBuilder::flag(StringRef Flag, bool Disallow) { tools::addMultilibFlag(!Disallow, Flag, Flags); return *this; } Multilib MultilibBuilder::makeMultilib() const { return Multilib(GCCSuffix, OSSuffix, IncludeSuffix, Flags); } MultilibSetBuilder &MultilibSetBuilder::Maybe(const MultilibBuilder &M) { MultilibBuilder Opposite; // Negate positive flags for (StringRef Flag : M.flags()) { if (Flag.front() == '-') Opposite.flag(Flag, /*Disallow=*/true); } return Either(M, Opposite); } MultilibSetBuilder &MultilibSetBuilder::Either(const MultilibBuilder &M1, const MultilibBuilder &M2) { return Either({M1, M2}); } MultilibSetBuilder &MultilibSetBuilder::Either(const MultilibBuilder &M1, const MultilibBuilder &M2, const MultilibBuilder &M3) { return Either({M1, M2, M3}); } MultilibSetBuilder &MultilibSetBuilder::Either(const MultilibBuilder &M1, const MultilibBuilder &M2, const MultilibBuilder &M3, const MultilibBuilder &M4) { return Either({M1, M2, M3, M4}); } MultilibSetBuilder &MultilibSetBuilder::Either(const MultilibBuilder &M1, const MultilibBuilder &M2, const MultilibBuilder &M3, const MultilibBuilder &M4, const MultilibBuilder &M5) { return Either({M1, M2, M3, M4, M5}); } static MultilibBuilder compose(const MultilibBuilder &Base, const MultilibBuilder &New) { SmallString<128> GCCSuffix; llvm::sys::path::append(GCCSuffix, "/", Base.gccSuffix(), New.gccSuffix()); SmallString<128> OSSuffix; llvm::sys::path::append(OSSuffix, "/", Base.osSuffix(), New.osSuffix()); SmallString<128> IncludeSuffix; llvm::sys::path::append(IncludeSuffix, "/", Base.includeSuffix(), New.includeSuffix()); MultilibBuilder Composed(GCCSuffix, OSSuffix, IncludeSuffix); MultilibBuilder::flags_list &Flags = Composed.flags(); Flags.insert(Flags.end(), Base.flags().begin(), Base.flags().end()); Flags.insert(Flags.end(), New.flags().begin(), New.flags().end()); return Composed; } MultilibSetBuilder & MultilibSetBuilder::Either(ArrayRef<MultilibBuilder> MultilibSegments) { multilib_list Composed; if (Multilibs.empty()) Multilibs.insert(Multilibs.end(), MultilibSegments.begin(), MultilibSegments.end()); else { for (const auto &New : MultilibSegments) { for (const auto &Base : Multilibs) { MultilibBuilder MO = compose(Base, New); if (MO.isValid()) Composed.push_back(MO); } } Multilibs = Composed; } return *this; } MultilibSetBuilder &MultilibSetBuilder::FilterOut(const char *Regex) { llvm::Regex R(Regex); #ifndef NDEBUG std::string Error; if (!R.isValid(Error)) { llvm::errs() << Error; llvm_unreachable("Invalid regex!"); } #endif llvm::erase_if(Multilibs, [&R](const MultilibBuilder &M) { return R.match(M.gccSuffix()); }); return *this; } MultilibSet MultilibSetBuilder::makeMultilibSet() const { MultilibSet Result; for (const auto &M : Multilibs) { Result.push_back(M.makeMultilib()); } return Result; }