clang 20.0.0git
MultilibBuilder.cpp
Go to the documentation of this file.
1//===- MultilibBuilder.cpp - MultilibBuilder 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
11#include "llvm/ADT/SmallString.h"
12#include "llvm/ADT/StringMap.h"
13#include "llvm/Support/Path.h"
14#include "llvm/Support/Regex.h"
15#include "llvm/Support/raw_ostream.h"
16
17using namespace clang;
18using namespace driver;
19
20/// normalize Segment to "/foo/bar" or "".
21static void normalizePathSegment(std::string &Segment) {
22 StringRef seg = Segment;
23
24 // Prune trailing "/" or "./"
25 while (true) {
26 StringRef last = llvm::sys::path::filename(seg);
27 if (last != ".")
28 break;
29 seg = llvm::sys::path::parent_path(seg);
30 }
31
32 if (seg.empty() || seg == "/") {
33 Segment.clear();
34 return;
35 }
36
37 // Add leading '/'
38 if (seg.front() != '/') {
39 Segment = "/" + seg.str();
40 } else {
41 Segment = std::string(seg);
42 }
43}
44
45MultilibBuilder::MultilibBuilder(StringRef GCC, StringRef OS, StringRef Include)
46 : GCCSuffix(GCC), OSSuffix(OS), IncludeSuffix(Include) {
47 normalizePathSegment(GCCSuffix);
48 normalizePathSegment(OSSuffix);
49 normalizePathSegment(IncludeSuffix);
50}
51
53 : MultilibBuilder(Suffix, Suffix, Suffix) {}
54
56 GCCSuffix = std::string(S);
57 normalizePathSegment(GCCSuffix);
58 return *this;
59}
60
62 OSSuffix = std::string(S);
63 normalizePathSegment(OSSuffix);
64 return *this;
65}
66
68 IncludeSuffix = std::string(S);
69 normalizePathSegment(IncludeSuffix);
70 return *this;
71}
72
74 llvm::StringMap<int> FlagSet;
75 for (unsigned I = 0, N = Flags.size(); I != N; ++I) {
76 StringRef Flag(Flags[I]);
77 llvm::StringMap<int>::iterator SI = FlagSet.find(Flag.substr(1));
78
79 assert(StringRef(Flag).front() == '-' || StringRef(Flag).front() == '!');
80
81 if (SI == FlagSet.end())
82 FlagSet[Flag.substr(1)] = I;
83 else if (Flags[I] != Flags[SI->getValue()])
84 return false;
85 }
86 return true;
87}
88
89MultilibBuilder &MultilibBuilder::flag(StringRef Flag, bool Disallow) {
90 tools::addMultilibFlag(!Disallow, Flag, Flags);
91 return *this;
92}
93
95 return Multilib(GCCSuffix, OSSuffix, IncludeSuffix, Flags);
96}
97
99 MultilibBuilder Opposite;
100 // Negate positive flags
101 for (StringRef Flag : M.flags()) {
102 if (Flag.front() == '-')
103 Opposite.flag(Flag, /*Disallow=*/true);
104 }
105 return Either(M, Opposite);
106}
107
109 const MultilibBuilder &M2) {
110 return Either({M1, M2});
111}
112
114 const MultilibBuilder &M2,
115 const MultilibBuilder &M3) {
116 return Either({M1, M2, M3});
117}
118
120 const MultilibBuilder &M2,
121 const MultilibBuilder &M3,
122 const MultilibBuilder &M4) {
123 return Either({M1, M2, M3, M4});
124}
125
127 const MultilibBuilder &M2,
128 const MultilibBuilder &M3,
129 const MultilibBuilder &M4,
130 const MultilibBuilder &M5) {
131 return Either({M1, M2, M3, M4, M5});
132}
133
135 const MultilibBuilder &New) {
136 SmallString<128> GCCSuffix;
137 llvm::sys::path::append(GCCSuffix, "/", Base.gccSuffix(), New.gccSuffix());
138 SmallString<128> OSSuffix;
139 llvm::sys::path::append(OSSuffix, "/", Base.osSuffix(), New.osSuffix());
140 SmallString<128> IncludeSuffix;
141 llvm::sys::path::append(IncludeSuffix, "/", Base.includeSuffix(),
142 New.includeSuffix());
143
144 MultilibBuilder Composed(GCCSuffix, OSSuffix, IncludeSuffix);
145
146 MultilibBuilder::flags_list &Flags = Composed.flags();
147
148 Flags.insert(Flags.end(), Base.flags().begin(), Base.flags().end());
149 Flags.insert(Flags.end(), New.flags().begin(), New.flags().end());
150
151 return Composed;
152}
153
156 multilib_list Composed;
157
158 if (Multilibs.empty())
159 Multilibs.insert(Multilibs.end(), MultilibSegments.begin(),
160 MultilibSegments.end());
161 else {
162 for (const auto &New : MultilibSegments) {
163 for (const auto &Base : Multilibs) {
164 MultilibBuilder MO = compose(Base, New);
165 if (MO.isValid())
166 Composed.push_back(MO);
167 }
168 }
169
170 Multilibs = Composed;
171 }
172
173 return *this;
174}
175
177 llvm::Regex R(Regex);
178#ifndef NDEBUG
179 std::string Error;
180 if (!R.isValid(Error)) {
181 llvm::errs() << Error;
182 llvm_unreachable("Invalid regex!");
183 }
184#endif
185 llvm::erase_if(Multilibs, [&R](const MultilibBuilder &M) {
186 return R.match(M.gccSuffix());
187 });
188 return *this;
189}
190
193 for (const auto &M : Multilibs) {
194 Result.push_back(M.makeMultilib());
195 }
196 return Result;
197}
static MultilibBuilder compose(const MultilibBuilder &Base, const MultilibBuilder &New)
static void normalizePathSegment(std::string &Segment)
normalize Segment to "/foo/bar" or "".
This corresponds to a single GCC multilib, or a segment of one controlled by a command line flag.
bool isValid() const
Check whether any of the 'against' flags contradict the 'for' flags.
MultilibBuilder & flag(StringRef Flag, bool Disallow=false)
Add a flag to the flags list Flag must be a flag accepted by the driver.
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
const std::string & includeSuffix() const
Get the include directory suffix.
const std::string & osSuffix() const
Get the detected os path suffix for the multi-arch target variant.
std::vector< std::string > flags_list
const flags_list & flags() const
Get the flags that indicate or contraindicate this multilib's use All elements begin with either '-' ...
MultilibBuilder(StringRef GCCSuffix, StringRef OSSuffix, StringRef IncludeSuffix)
This class can be used to create a MultilibSet, and contains helper functions to add combinations of ...
MultilibSetBuilder & Maybe(const MultilibBuilder &M)
Add an optional Multilib segment.
MultilibSetBuilder & FilterOut(const char *Regex)
Filter out those Multilibs whose gccSuffix matches the given expression.
MultilibSetBuilder & Either(const MultilibBuilder &M1, const MultilibBuilder &M2)
Add a set of mutually incompatible Multilib segments.
std::vector< MultilibBuilder > multilib_list
See also MultilibSetBuilder for combining multilibs into a set.
Definition: Multilib.h:92
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag.
Definition: Multilib.h:32
void addMultilibFlag(bool Enabled, const StringRef Flag, Multilib::flags_list &Flags)
Flag must be a flag accepted by the driver.
The JSON file list parser is used to communicate input to InstallAPI.
@ Result
The result type of a method or function.