diff options
Diffstat (limited to 'contrib/llvm-project/clang/lib/Driver/MultilibBuilder.cpp')
| -rw-r--r-- | contrib/llvm-project/clang/lib/Driver/MultilibBuilder.cpp | 197 |
1 files changed, 197 insertions, 0 deletions
diff --git a/contrib/llvm-project/clang/lib/Driver/MultilibBuilder.cpp b/contrib/llvm-project/clang/lib/Driver/MultilibBuilder.cpp new file mode 100644 index 000000000000..15adf5017780 --- /dev/null +++ b/contrib/llvm-project/clang/lib/Driver/MultilibBuilder.cpp @@ -0,0 +1,197 @@ +//===- 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; +} |