LLVM 20.0.0git
InterfaceFile.cpp
Go to the documentation of this file.
1//===- InterfaceFile.cpp --------------------------------------------------===//
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// Implements the Interface File.
10//
11//===----------------------------------------------------------------------===//
12
16#include <iomanip>
17#include <sstream>
18
19using namespace llvm;
20using namespace llvm::MachO;
21
23 addEntry(Targets, Target);
24}
25
27 const Target &Target) {
28 if (InstallName.empty())
29 return;
30 auto Client = addEntry(AllowableClients, InstallName);
31 Client->addTarget(Target);
32}
33
35 const Target &Target) {
36 if (InstallName.empty())
37 return;
38 auto Lib = addEntry(ReexportedLibraries, InstallName);
39 Lib->addTarget(Target);
40}
41
43 if (Parent.empty())
44 return;
45 auto Iter = lower_bound(ParentUmbrellas, Target_,
46 [](const std::pair<Target, std::string> &LHS,
47 Target RHS) { return LHS.first < RHS; });
48
49 if ((Iter != ParentUmbrellas.end()) && !(Target_ < Iter->first)) {
50 Iter->second = std::string(Parent);
51 return;
52 }
53
54 ParentUmbrellas.emplace(Iter, Target_, std::string(Parent));
55}
56
57void InterfaceFile::addRPath(StringRef RPath, const Target &InputTarget) {
58 if (RPath.empty())
59 return;
60 using RPathEntryT = const std::pair<Target, std::string>;
61 RPathEntryT Entry(InputTarget, RPath);
62 auto Iter =
63 lower_bound(RPaths, Entry,
64 [](RPathEntryT &LHS, RPathEntryT &RHS) { return LHS < RHS; });
65
66 if ((Iter != RPaths.end()) && (*Iter == Entry))
67 return;
68
69 RPaths.emplace(Iter, Entry);
70}
71
73 addEntry(Targets, Target);
74}
75
78 std::function<bool(const Target &)> fn = [Archs](const Target &Target_) {
79 return Archs.has(Target_.Arch);
80 };
81 return make_filter_range(Targets, fn);
82}
83
84void InterfaceFile::addDocument(std::shared_ptr<InterfaceFile> &&Document) {
85 auto Pos = llvm::lower_bound(Documents, Document,
86 [](const std::shared_ptr<InterfaceFile> &LHS,
87 const std::shared_ptr<InterfaceFile> &RHS) {
88 return LHS->InstallName < RHS->InstallName;
89 });
90 assert((Pos == Documents.end() ||
91 (*Pos)->InstallName != Document->InstallName) &&
92 "Unexpected duplicate document added");
93 Document->Parent = this;
94 Documents.insert(Pos, Document);
95}
96
97void InterfaceFile::inlineLibrary(std::shared_ptr<InterfaceFile> Library,
98 bool Overwrite) {
99 auto AddFwk = [&](std::shared_ptr<InterfaceFile> &&Reexport) {
100 auto It = lower_bound(
101 Documents, Reexport->getInstallName(),
102 [](std::shared_ptr<InterfaceFile> &Lhs, const StringRef Rhs) {
103 return Lhs->getInstallName() < Rhs;
104 });
105
106 if (Overwrite && It != Documents.end() &&
107 Reexport->getInstallName() == (*It)->getInstallName()) {
108 std::replace(Documents.begin(), Documents.end(), *It,
109 std::move(Reexport));
110 return;
111 }
112
113 if ((It != Documents.end()) &&
114 !(Reexport->getInstallName() < (*It)->getInstallName()))
115 return;
116
117 Documents.emplace(It, std::move(Reexport));
118 };
119 for (auto Doc : Library->documents())
120 AddFwk(std::move(Doc));
121
122 Library->Documents.clear();
123 AddFwk(std::move(Library));
124}
125
128 // Verify files can be merged.
129 if (getInstallName() != O->getInstallName()) {
130 return make_error<StringError>("install names do not match",
132 }
133
134 if (getCurrentVersion() != O->getCurrentVersion()) {
135 return make_error<StringError>("current versions do not match",
137 }
138
139 if (getCompatibilityVersion() != O->getCompatibilityVersion()) {
140 return make_error<StringError>("compatibility versions do not match",
142 }
143
144 if ((getSwiftABIVersion() != 0) && (O->getSwiftABIVersion() != 0) &&
145 (getSwiftABIVersion() != O->getSwiftABIVersion())) {
146 return make_error<StringError>("swift ABI versions do not match",
148 }
149
150 if (isTwoLevelNamespace() != O->isTwoLevelNamespace()) {
151 return make_error<StringError>("two level namespace flags do not match",
153 }
154
155 if (isApplicationExtensionSafe() != O->isApplicationExtensionSafe()) {
156 return make_error<StringError>(
157 "application extension safe flags do not match",
159 }
160
161 std::unique_ptr<InterfaceFile> IF(new InterfaceFile());
162 IF->setFileType(std::max(getFileType(), O->getFileType()));
163 IF->setPath(getPath());
164 IF->setInstallName(getInstallName());
165 IF->setCurrentVersion(getCurrentVersion());
166 IF->setCompatibilityVersion(getCompatibilityVersion());
167
168 if (getSwiftABIVersion() == 0)
169 IF->setSwiftABIVersion(O->getSwiftABIVersion());
170 else
171 IF->setSwiftABIVersion(getSwiftABIVersion());
172
173 IF->setTwoLevelNamespace(isTwoLevelNamespace());
174 IF->setApplicationExtensionSafe(isApplicationExtensionSafe());
175 IF->setOSLibNotForSharedCache(isOSLibNotForSharedCache());
176
177 for (const auto &It : umbrellas()) {
178 if (!It.second.empty())
179 IF->addParentUmbrella(It.first, It.second);
180 }
181 for (const auto &It : O->umbrellas()) {
182 if (!It.second.empty())
183 IF->addParentUmbrella(It.first, It.second);
184 }
185 IF->addTargets(targets());
186 IF->addTargets(O->targets());
187
188 for (const auto &Lib : allowableClients())
189 for (const auto &Target : Lib.targets())
190 IF->addAllowableClient(Lib.getInstallName(), Target);
191
192 for (const auto &Lib : O->allowableClients())
193 for (const auto &Target : Lib.targets())
194 IF->addAllowableClient(Lib.getInstallName(), Target);
195
196 for (const auto &Lib : reexportedLibraries())
197 for (const auto &Target : Lib.targets())
198 IF->addReexportedLibrary(Lib.getInstallName(), Target);
199
200 for (const auto &Lib : O->reexportedLibraries())
201 for (const auto &Target : Lib.targets())
202 IF->addReexportedLibrary(Lib.getInstallName(), Target);
203
204 for (const auto &[Target, Path] : rpaths())
205 IF->addRPath(Path, Target);
206 for (const auto &[Target, Path] : O->rpaths())
207 IF->addRPath(Path, Target);
208
209 for (const auto *Sym : symbols()) {
210 IF->addSymbol(Sym->getKind(), Sym->getName(), Sym->targets(),
211 Sym->getFlags());
212 }
213
214 for (const auto *Sym : O->symbols()) {
215 IF->addSymbol(Sym->getKind(), Sym->getName(), Sym->targets(),
216 Sym->getFlags());
217 }
218
219 return std::move(IF);
220}
221
224 if (getArchitectures() == Arch)
225 return make_error<StringError>("cannot remove last architecture slice '" +
226 getArchitectureName(Arch) + "'",
228
229 if (!getArchitectures().has(Arch)) {
230 bool Found = false;
231 for (auto &Doc : Documents) {
232 if (Doc->getArchitectures().has(Arch)) {
233 Found = true;
234 break;
235 }
236 }
237
238 if (!Found)
239 return make_error<TextAPIError>(TextAPIErrorCode::NoSuchArchitecture);
240 }
241
242 // FIXME: Figure out how to keep these attributes in sync when new ones are
243 // added.
244 std::unique_ptr<InterfaceFile> IF(new InterfaceFile());
245 IF->setFileType(getFileType());
246 IF->setPath(getPath());
247 IF->addTargets(targets(ArchitectureSet::All().clear(Arch)));
248 IF->setInstallName(getInstallName());
249 IF->setCurrentVersion(getCurrentVersion());
250 IF->setCompatibilityVersion(getCompatibilityVersion());
251 IF->setSwiftABIVersion(getSwiftABIVersion());
252 IF->setTwoLevelNamespace(isTwoLevelNamespace());
253 IF->setApplicationExtensionSafe(isApplicationExtensionSafe());
254 IF->setOSLibNotForSharedCache(isOSLibNotForSharedCache());
255 for (const auto &It : umbrellas())
256 if (It.first.Arch != Arch)
257 IF->addParentUmbrella(It.first, It.second);
258
259 for (const auto &Lib : allowableClients()) {
260 for (const auto &Target : Lib.targets())
261 if (Target.Arch != Arch)
262 IF->addAllowableClient(Lib.getInstallName(), Target);
263 }
264
265 for (const auto &Lib : reexportedLibraries()) {
266 for (const auto &Target : Lib.targets())
267 if (Target.Arch != Arch)
268 IF->addReexportedLibrary(Lib.getInstallName(), Target);
269 }
270
271 for (const auto *Sym : symbols()) {
272 auto Archs = Sym->getArchitectures();
273 Archs.clear(Arch);
274 if (Archs.empty())
275 continue;
276
277 IF->addSymbol(Sym->getKind(), Sym->getName(), Sym->targets(Archs),
278 Sym->getFlags());
279 }
280
281 for (auto &Doc : Documents) {
282 // Skip the inlined document if the to be removed architecture is the
283 // only one left.
284 if (Doc->getArchitectures() == Arch)
285 continue;
286
287 // If the document doesn't contain the arch, then no work is to be done
288 // and it can be copied over.
289 if (!Doc->getArchitectures().has(Arch)) {
290 auto NewDoc = Doc;
291 IF->addDocument(std::move(NewDoc));
292 continue;
293 }
294
295 auto Result = Doc->remove(Arch);
296 if (!Result)
297 return Result;
298
299 IF->addDocument(std::move(Result.get()));
300 }
301
302 return std::move(IF);
303}
304
307 if (!getArchitectures().has(Arch)) {
308 return make_error<StringError>("file doesn't have architecture '" +
309 getArchitectureName(Arch) + "'",
311 }
312
313 std::unique_ptr<InterfaceFile> IF(new InterfaceFile());
314 IF->setFileType(getFileType());
315 IF->setPath(getPath());
316 IF->addTargets(targets(Arch));
317 IF->setInstallName(getInstallName());
318 IF->setCurrentVersion(getCurrentVersion());
319 IF->setCompatibilityVersion(getCompatibilityVersion());
320 IF->setSwiftABIVersion(getSwiftABIVersion());
321 IF->setTwoLevelNamespace(isTwoLevelNamespace());
322 IF->setApplicationExtensionSafe(isApplicationExtensionSafe());
323 IF->setOSLibNotForSharedCache(isOSLibNotForSharedCache());
324 for (const auto &It : umbrellas())
325 if (It.first.Arch == Arch)
326 IF->addParentUmbrella(It.first, It.second);
327
328 for (const auto &It : rpaths())
329 if (It.first.Arch == Arch)
330 IF->addRPath(It.second, It.first);
331
332 for (const auto &Lib : allowableClients())
333 for (const auto &Target : Lib.targets())
334 if (Target.Arch == Arch)
335 IF->addAllowableClient(Lib.getInstallName(), Target);
336
337 for (const auto &Lib : reexportedLibraries())
338 for (const auto &Target : Lib.targets())
339 if (Target.Arch == Arch)
340 IF->addReexportedLibrary(Lib.getInstallName(), Target);
341
342 for (const auto *Sym : symbols()) {
343 if (Sym->hasArchitecture(Arch))
344 IF->addSymbol(Sym->getKind(), Sym->getName(), Sym->targets(Arch),
345 Sym->getFlags());
346 }
347
348 for (auto &Doc : Documents) {
349 // Skip documents that don't have the requested architecture.
350 if (!Doc->getArchitectures().has(Arch))
351 continue;
352
353 auto Result = Doc->extract(Arch);
354 if (!Result)
355 return Result;
356
357 IF->addDocument(std::move(Result.get()));
358 }
359
360 return std::move(IF);
361}
362
364 const Target &Targ) {
365 if (getFileType() != BA.File)
366 setFileType(BA.File);
367 if (getInstallName().empty())
375 if (getCurrentVersion().empty())
377 if (getCompatibilityVersion().empty())
379 if (getSwiftABIVersion() == 0)
381 if (getPath().empty())
382 setPath(BA.Path);
383 if (!BA.ParentUmbrella.empty())
385 for (const auto &Client : BA.AllowableClients)
386 addAllowableClient(Client, Targ);
387 for (const auto &Lib : BA.RexportedLibraries)
389}
390
391static bool isYAMLTextStub(const FileType &Kind) {
392 return (Kind >= FileType::TBD_V1) && (Kind < FileType::TBD_V5);
393}
394
396 if (Targets != O.Targets)
397 return false;
398 if (InstallName != O.InstallName)
399 return false;
400 if ((CurrentVersion != O.CurrentVersion) ||
401 (CompatibilityVersion != O.CompatibilityVersion))
402 return false;
403 if (SwiftABIVersion != O.SwiftABIVersion)
404 return false;
405 if (IsTwoLevelNamespace != O.IsTwoLevelNamespace)
406 return false;
407 if (IsAppExtensionSafe != O.IsAppExtensionSafe)
408 return false;
409 if (IsOSLibNotForSharedCache != O.IsOSLibNotForSharedCache)
410 return false;
411 if (HasSimSupport != O.HasSimSupport)
412 return false;
413 if (ParentUmbrellas != O.ParentUmbrellas)
414 return false;
415 if (AllowableClients != O.AllowableClients)
416 return false;
417 if (ReexportedLibraries != O.ReexportedLibraries)
418 return false;
419 if (*SymbolsSet != *O.SymbolsSet)
420 return false;
421 // Don't compare run search paths for older filetypes that cannot express
422 // them.
423 if (!(isYAMLTextStub(FileKind)) && !(isYAMLTextStub(O.FileKind))) {
424 if (RPaths != O.RPaths)
425 return false;
426 if (mapToPlatformVersionSet(Targets) != mapToPlatformVersionSet(O.Targets))
427 return false;
428 }
429
430 if (!std::equal(Documents.begin(), Documents.end(), O.Documents.begin(),
431 O.Documents.end(),
432 [](const std::shared_ptr<InterfaceFile> LHS,
433 const std::shared_ptr<InterfaceFile> RHS) {
434 return *LHS == *RHS;
435 }))
436 return false;
437 return true;
438}
Symbol * Sym
Definition: ELF_riscv.cpp:479
static bool isYAMLTextStub(const FileType &Kind)
Implements the TAPI Record Collection Type.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Define TAPI specific error codes.
Value * RHS
Value * LHS
Tagged union holding either a T or a Error.
Definition: Error.h:481
static ArchitectureSet All()
ArchitectureSet clear(Architecture Arch)
bool has(Architecture Arch) const
void addTarget(const Target &Target)
Defines the interface file.
void addDocument(std::shared_ptr< InterfaceFile > &&Document)
Add a library for inlining to top level library.
StringRef getPath() const
Get the path from which this file was generated (if applicable).
void addReexportedLibrary(StringRef InstallName, const Target &Target)
Add a re-exported library.
void setPath(StringRef Path_)
Set the path from which this file was generated (if applicable).
void setFromBinaryAttrs(const RecordsSlice::BinaryAttrs &BA, const Target &Targ)
Set InterfaceFile properties from pre-gathered binary attributes, if they are not set already.
void addParentUmbrella(const Target &Target_, StringRef Parent)
Set the parent umbrella frameworks.
const_target_range targets() const
void setOSLibNotForSharedCache(bool V=true)
Specify if the library is an OS library but not shared cache eligible.
bool isOSLibNotForSharedCache() const
Check if the library is an OS library that is not shared cache eligible.
llvm::Expected< std::unique_ptr< InterfaceFile > > remove(Architecture Arch) const
Remove architecture slice from Interface.
bool isTwoLevelNamespace() const
Check if the library uses two-level namespace.
bool operator==(const InterfaceFile &O) const
The equality is determined by attributes that impact linking compatibilities.
PackedVersion getCompatibilityVersion() const
Get the compatibility version of the library.
void addTarget(const Target &Target)
Set and add target.
bool isApplicationExtensionSafe() const
Check if the library is application extension safe.
const std::vector< std::pair< Target, std::string > > & rpaths() const
Get the list of runpath search paths.
const std::vector< InterfaceFileRef > & allowableClients() const
Get the list of allowable clients.
void setInstallName(StringRef InstallName_)
Set the install name of the library.
const std::vector< std::pair< Target, std::string > > & umbrellas() const
Get the list of Parent Umbrella frameworks.
const std::vector< InterfaceFileRef > & reexportedLibraries() const
Get the list of re-exported libraries.
const_symbol_range symbols() const
void setFileType(FileType Kind)
Set the file type.
uint8_t getSwiftABIVersion() const
Get the Swift ABI version of the library.
PackedVersion getCurrentVersion() const
Get the current version of the library.
void addRPath(StringRef RPath, const Target &InputTarget)
Set the runpath search paths.
void setCompatibilityVersion(PackedVersion Version)
Set the compatibility version of the library.
ArchitectureSet getArchitectures() const
Get the architectures.
StringRef getInstallName() const
Get the install name of the library.
llvm::Expected< std::unique_ptr< InterfaceFile > > merge(const InterfaceFile *O) const
Merge Interfaces for the same library.
FileType getFileType() const
Get the file type.
void setApplicationExtensionSafe(bool V=true)
Specify if the library is application extension safe (or not).
void addAllowableClient(StringRef InstallName, const Target &Target)
Add an allowable client.
void inlineLibrary(std::shared_ptr< InterfaceFile > Library, bool Overwrite=false)
Inline reexported library into Interface.
void setSwiftABIVersion(uint8_t Version)
Set the Swift ABI version of the library.
void setCurrentVersion(PackedVersion Version)
Set the current version of the library.
llvm::Expected< std::unique_ptr< InterfaceFile > > extract(Architecture Arch) const
Extract architecture slice from Interface.
void setTwoLevelNamespace(bool V=true)
Specify if the library uses two-level namespace (or flat namespace).
SymbolFlags getFlags() const
Definition: Symbol.h:107
bool hasArchitecture(Architecture Arch) const
Definition: Symbol.h:138
const_target_range targets() const
Definition: Symbol.h:148
ArchitectureSet getArchitectures() const
Definition: Symbol.h:104
StringRef getName() const
Definition: Symbol.h:103
EncodeKind getKind() const
Definition: Symbol.h:102
Architecture Arch
Definition: Target.h:42
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:51
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:147
A range adaptor for a pair of iterators.
FileType
Defines the file type TextAPI files can represent.
Definition: FileTypes.h:15
@ TBD_V1
Text-based stub file (.tbd) version 1.0.
Definition: FileTypes.h:29
@ TBD_V5
Text-based stub file (.tbd) version 5.0.
Definition: FileTypes.h:41
StringRef getArchitectureName(Architecture Arch)
Convert an architecture slice to a string.
C::iterator addEntry(C &Container, StringRef InstallName)
Architecture
Defines the architecture slices that are supported by Text-based Stub files.
Definition: Architecture.h:27
PlatformVersionSet mapToPlatformVersionSet(ArrayRef< Target > Targets)
Definition: Target.cpp:55
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:98
iterator_range< filter_iterator< detail::IterOfRange< RangeT >, PredicateT > > make_filter_range(RangeT &&Range, PredicateT Pred)
Convenience function that takes a range of elements and a predicate, and return a new filter_iterator...
Definition: STLExtras.h:573
auto lower_bound(R &&Range, T &&Value)
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1978
std::vector< StringRef > RexportedLibraries
Definition: RecordsSlice.h:145
std::vector< StringRef > AllowableClients
Definition: RecordsSlice.h:144
llvm::MachO::PackedVersion CompatVersion
Definition: RecordsSlice.h:153
llvm::MachO::PackedVersion CurrentVersion
Definition: RecordsSlice.h:152