LLVM 20.0.0git
TextStub.cpp
Go to the documentation of this file.
1//===- TextStub.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 text stub file reader/writer.
10//
11//===----------------------------------------------------------------------===//
12
13#include "TextAPIContext.h"
14#include "TextStubCommon.h"
17#include "llvm/ADT/StringRef.h"
28#include <algorithm>
29#include <set>
30
31// clang-format off
32/*
33
34 YAML Format specification.
35
36 The TBD v1 format only support two level address libraries and is per
37 definition application extension safe.
38
39--- # the tag !tapi-tbd-v1 is optional and
40 # shouldn't be emitted to support older linker.
41archs: [ armv7, armv7s, arm64 ] # the list of architecture slices that are
42 # supported by this file.
43platform: ios # Specifies the platform (macosx, ios, etc)
44install-name: /u/l/libfoo.dylib #
45current-version: 1.2.3 # Optional: defaults to 1.0
46compatibility-version: 1.0 # Optional: defaults to 1.0
47swift-version: 0 # Optional: defaults to 0
48objc-constraint: none # Optional: defaults to none
49exports: # List of export sections
50...
51
52Each export section is defined as following:
53
54 - archs: [ arm64 ] # the list of architecture slices
55 allowed-clients: [ client ] # Optional: List of clients
56 re-exports: [ ] # Optional: List of re-exports
57 symbols: [ _sym ] # Optional: List of symbols
58 objc-classes: [] # Optional: List of Objective-C classes
59 objc-ivars: [] # Optional: List of Objective C Instance
60 # Variables
61 weak-def-symbols: [] # Optional: List of weak defined symbols
62 thread-local-symbols: [] # Optional: List of thread local symbols
63*/
64
65/*
66
67 YAML Format specification.
68
69--- !tapi-tbd-v2
70archs: [ armv7, armv7s, arm64 ] # the list of architecture slices that are
71 # supported by this file.
72uuids: [ armv7:... ] # Optional: List of architecture and UUID pairs.
73platform: ios # Specifies the platform (macosx, ios, etc)
74flags: [] # Optional:
75install-name: /u/l/libfoo.dylib #
76current-version: 1.2.3 # Optional: defaults to 1.0
77compatibility-version: 1.0 # Optional: defaults to 1.0
78swift-version: 0 # Optional: defaults to 0
79objc-constraint: retain_release # Optional: defaults to retain_release
80parent-umbrella: # Optional:
81exports: # List of export sections
82...
83undefineds: # List of undefineds sections
84...
85
86Each export section is defined as following:
87
88- archs: [ arm64 ] # the list of architecture slices
89 allowed-clients: [ client ] # Optional: List of clients
90 re-exports: [ ] # Optional: List of re-exports
91 symbols: [ _sym ] # Optional: List of symbols
92 objc-classes: [] # Optional: List of Objective-C classes
93 objc-ivars: [] # Optional: List of Objective C Instance
94 # Variables
95 weak-def-symbols: [] # Optional: List of weak defined symbols
96 thread-local-symbols: [] # Optional: List of thread local symbols
97
98Each undefineds section is defined as following:
99- archs: [ arm64 ] # the list of architecture slices
100 symbols: [ _sym ] # Optional: List of symbols
101 objc-classes: [] # Optional: List of Objective-C classes
102 objc-ivars: [] # Optional: List of Objective C Instance Variables
103 weak-ref-symbols: [] # Optional: List of weak defined symbols
104*/
105
106/*
107
108 YAML Format specification.
109
110--- !tapi-tbd-v3
111archs: [ armv7, armv7s, arm64 ] # the list of architecture slices that are
112 # supported by this file.
113uuids: [ armv7:... ] # Optional: List of architecture and UUID pairs.
114platform: ios # Specifies the platform (macosx, ios, etc)
115flags: [] # Optional:
116install-name: /u/l/libfoo.dylib #
117current-version: 1.2.3 # Optional: defaults to 1.0
118compatibility-version: 1.0 # Optional: defaults to 1.0
119swift-abi-version: 0 # Optional: defaults to 0
120objc-constraint: retain_release # Optional: defaults to retain_release
121parent-umbrella: # Optional:
122exports: # List of export sections
123...
124undefineds: # List of undefineds sections
125...
126
127Each export section is defined as following:
128
129- archs: [ arm64 ] # the list of architecture slices
130 allowed-clients: [ client ] # Optional: List of clients
131 re-exports: [ ] # Optional: List of re-exports
132 symbols: [ _sym ] # Optional: List of symbols
133 objc-classes: [] # Optional: List of Objective-C classes
134 objc-eh-types: [] # Optional: List of Objective-C classes
135 # with EH
136 objc-ivars: [] # Optional: List of Objective C Instance
137 # Variables
138 weak-def-symbols: [] # Optional: List of weak defined symbols
139 thread-local-symbols: [] # Optional: List of thread local symbols
140
141Each undefineds section is defined as following:
142- archs: [ arm64 ] # the list of architecture slices
143 symbols: [ _sym ] # Optional: List of symbols
144 objc-classes: [] # Optional: List of Objective-C classes
145 objc-eh-types: [] # Optional: List of Objective-C classes
146 # with EH
147 objc-ivars: [] # Optional: List of Objective C Instance Variables
148 weak-ref-symbols: [] # Optional: List of weak defined symbols
149*/
150
151/*
152
153 YAML Format specification.
154
155--- !tapi-tbd
156tbd-version: 4 # The tbd version for format
157targets: [ armv7-ios, x86_64-maccatalyst ] # The list of applicable tapi supported target triples
158uuids: # Optional: List of target and UUID pairs.
159 - target: armv7-ios
160 value: ...
161 - target: x86_64-maccatalyst
162 value: ...
163flags: [] # Optional:
164install-name: /u/l/libfoo.dylib #
165current-version: 1.2.3 # Optional: defaults to 1.0
166compatibility-version: 1.0 # Optional: defaults to 1.0
167swift-abi-version: 0 # Optional: defaults to 0
168parent-umbrella: # Optional:
169allowable-clients:
170 - targets: [ armv7-ios ] # Optional:
171 clients: [ clientA ]
172exports: # List of export sections
173...
174re-exports: # List of reexport sections
175...
176undefineds: # List of undefineds sections
177...
178
179Each export and reexport section is defined as following:
180
181- targets: [ arm64-macos ] # The list of target triples associated with symbols
182 symbols: [ _symA ] # Optional: List of symbols
183 objc-classes: [] # Optional: List of Objective-C classes
184 objc-eh-types: [] # Optional: List of Objective-C classes
185 # with EH
186 objc-ivars: [] # Optional: List of Objective C Instance
187 # Variables
188 weak-symbols: [] # Optional: List of weak defined symbols
189 thread-local-symbols: [] # Optional: List of thread local symbols
190- targets: [ arm64-macos, x86_64-maccatalyst ] # Optional: Targets for applicable additional symbols
191 symbols: [ _symB ] # Optional: List of symbols
192
193Each undefineds section is defined as following:
194- targets: [ arm64-macos ] # The list of target triples associated with symbols
195 symbols: [ _symC ] # Optional: List of symbols
196 objc-classes: [] # Optional: List of Objective-C classes
197 objc-eh-types: [] # Optional: List of Objective-C classes
198 # with EH
199 objc-ivars: [] # Optional: List of Objective C Instance Variables
200 weak-symbols: [] # Optional: List of weak defined symbols
201*/
202// clang-format on
203
204using namespace llvm;
205using namespace llvm::yaml;
206using namespace llvm::MachO;
207
208namespace {
209struct ExportSection {
210 std::vector<Architecture> Architectures;
211 std::vector<FlowStringRef> AllowableClients;
212 std::vector<FlowStringRef> ReexportedLibraries;
213 std::vector<FlowStringRef> Symbols;
214 std::vector<FlowStringRef> Classes;
215 std::vector<FlowStringRef> ClassEHs;
216 std::vector<FlowStringRef> IVars;
217 std::vector<FlowStringRef> WeakDefSymbols;
218 std::vector<FlowStringRef> TLVSymbols;
219};
220
221struct UndefinedSection {
222 std::vector<Architecture> Architectures;
223 std::vector<FlowStringRef> Symbols;
224 std::vector<FlowStringRef> Classes;
225 std::vector<FlowStringRef> ClassEHs;
226 std::vector<FlowStringRef> IVars;
227 std::vector<FlowStringRef> WeakRefSymbols;
228};
229
230// Sections for direct target mapping in TBDv4
231struct SymbolSection {
232 TargetList Targets;
233 std::vector<FlowStringRef> Symbols;
234 std::vector<FlowStringRef> Classes;
235 std::vector<FlowStringRef> ClassEHs;
236 std::vector<FlowStringRef> Ivars;
237 std::vector<FlowStringRef> WeakSymbols;
238 std::vector<FlowStringRef> TlvSymbols;
239};
240
241struct MetadataSection {
242 enum Option { Clients, Libraries };
243 std::vector<Target> Targets;
244 std::vector<FlowStringRef> Values;
245};
246
247struct UmbrellaSection {
248 std::vector<Target> Targets;
249 std::string Umbrella;
250};
251
252// UUID's for TBDv4 are mapped to target not arch
253struct UUIDv4 {
254 Target TargetID;
255 std::string Value;
256
257 UUIDv4() = default;
258 UUIDv4(const Target &TargetID, const std::string &Value)
259 : TargetID(TargetID), Value(Value) {}
260};
261} // end anonymous namespace.
262
264LLVM_YAML_IS_SEQUENCE_VECTOR(ExportSection)
265LLVM_YAML_IS_SEQUENCE_VECTOR(UndefinedSection)
266// Specific to TBDv4
267LLVM_YAML_IS_SEQUENCE_VECTOR(SymbolSection)
268LLVM_YAML_IS_SEQUENCE_VECTOR(MetadataSection)
269LLVM_YAML_IS_SEQUENCE_VECTOR(UmbrellaSection)
272
273namespace llvm {
274namespace yaml {
275
276template <> struct MappingTraits<ExportSection> {
277 static void mapping(IO &IO, ExportSection &Section) {
278 const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
279 assert((!Ctx || Ctx->FileKind != FileType::Invalid) &&
280 "File type is not set in YAML context");
281
282 IO.mapRequired("archs", Section.Architectures);
283 if (Ctx->FileKind == FileType::TBD_V1)
284 IO.mapOptional("allowed-clients", Section.AllowableClients);
285 else
286 IO.mapOptional("allowable-clients", Section.AllowableClients);
287 IO.mapOptional("re-exports", Section.ReexportedLibraries);
288 IO.mapOptional("symbols", Section.Symbols);
289 IO.mapOptional("objc-classes", Section.Classes);
290 if (Ctx->FileKind == FileType::TBD_V3)
291 IO.mapOptional("objc-eh-types", Section.ClassEHs);
292 IO.mapOptional("objc-ivars", Section.IVars);
293 IO.mapOptional("weak-def-symbols", Section.WeakDefSymbols);
294 IO.mapOptional("thread-local-symbols", Section.TLVSymbols);
295 }
296};
297
298template <> struct MappingTraits<UndefinedSection> {
299 static void mapping(IO &IO, UndefinedSection &Section) {
300 const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
301 assert((!Ctx || Ctx->FileKind != FileType::Invalid) &&
302 "File type is not set in YAML context");
303
304 IO.mapRequired("archs", Section.Architectures);
305 IO.mapOptional("symbols", Section.Symbols);
306 IO.mapOptional("objc-classes", Section.Classes);
307 if (Ctx->FileKind == FileType::TBD_V3)
308 IO.mapOptional("objc-eh-types", Section.ClassEHs);
309 IO.mapOptional("objc-ivars", Section.IVars);
310 IO.mapOptional("weak-ref-symbols", Section.WeakRefSymbols);
311 }
312};
313
314template <> struct MappingTraits<SymbolSection> {
315 static void mapping(IO &IO, SymbolSection &Section) {
316 IO.mapRequired("targets", Section.Targets);
317 IO.mapOptional("symbols", Section.Symbols);
318 IO.mapOptional("objc-classes", Section.Classes);
319 IO.mapOptional("objc-eh-types", Section.ClassEHs);
320 IO.mapOptional("objc-ivars", Section.Ivars);
321 IO.mapOptional("weak-symbols", Section.WeakSymbols);
322 IO.mapOptional("thread-local-symbols", Section.TlvSymbols);
323 }
324};
325
326template <> struct MappingTraits<UmbrellaSection> {
327 static void mapping(IO &IO, UmbrellaSection &Section) {
328 IO.mapRequired("targets", Section.Targets);
329 IO.mapRequired("umbrella", Section.Umbrella);
330 }
331};
332
333template <> struct MappingTraits<UUIDv4> {
334 static void mapping(IO &IO, UUIDv4 &UUID) {
335 IO.mapRequired("target", UUID.TargetID);
336 IO.mapRequired("value", UUID.Value);
337 }
338};
339
340template <>
341struct MappingContextTraits<MetadataSection, MetadataSection::Option> {
342 static void mapping(IO &IO, MetadataSection &Section,
343 MetadataSection::Option &OptionKind) {
344 IO.mapRequired("targets", Section.Targets);
345 switch (OptionKind) {
346 case MetadataSection::Option::Clients:
347 IO.mapRequired("clients", Section.Values);
348 return;
349 case MetadataSection::Option::Libraries:
350 IO.mapRequired("libraries", Section.Values);
351 return;
352 }
353 llvm_unreachable("unexpected option for metadata");
354 }
355};
356
357template <> struct ScalarBitSetTraits<TBDFlags> {
358 static void bitset(IO &IO, TBDFlags &Flags) {
359 IO.bitSetCase(Flags, "flat_namespace", TBDFlags::FlatNamespace);
360 IO.bitSetCase(Flags, "not_app_extension_safe",
361 TBDFlags::NotApplicationExtensionSafe);
362 IO.bitSetCase(Flags, "installapi", TBDFlags::InstallAPI);
363 IO.bitSetCase(Flags, "not_for_dyld_shared_cache",
364 TBDFlags::OSLibNotForSharedCache);
365 }
366};
367
368template <> struct ScalarTraits<Target> {
369 static void output(const Target &Value, void *, raw_ostream &OS) {
370 OS << Value.Arch << "-";
371 switch (Value.Platform) {
372#define PLATFORM(platform, id, name, build_name, target, tapi_target, \
373 marketing) \
374 case PLATFORM_##platform: \
375 OS << #tapi_target; \
376 break;
377#include "llvm/BinaryFormat/MachO.def"
378 }
379 }
380
381 static StringRef input(StringRef Scalar, void *, Target &Value) {
382 auto Result = Target::create(Scalar);
383 if (!Result) {
384 consumeError(Result.takeError());
385 return "unparsable target";
386 }
387
388 Value = *Result;
389 if (Value.Arch == AK_unknown)
390 return "unknown architecture";
391 if (Value.Platform == PLATFORM_UNKNOWN)
392 return "unknown platform";
393
394 return {};
395 }
396
397 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
398};
399
400template <> struct MappingTraits<const InterfaceFile *> {
401 struct NormalizedTBD {
402 explicit NormalizedTBD(IO &IO) {}
403 NormalizedTBD(IO &IO, const InterfaceFile *&File) {
404 Architectures = File->getArchitectures();
405 Platforms = File->getPlatforms();
406 InstallName = File->getInstallName();
407 CurrentVersion = PackedVersion(File->getCurrentVersion());
408 CompatibilityVersion = PackedVersion(File->getCompatibilityVersion());
409 SwiftABIVersion = File->getSwiftABIVersion();
410 ObjCConstraint = File->getObjCConstraint();
411
412 Flags = TBDFlags::None;
413 if (!File->isApplicationExtensionSafe())
414 Flags |= TBDFlags::NotApplicationExtensionSafe;
415
416 if (!File->isTwoLevelNamespace())
417 Flags |= TBDFlags::FlatNamespace;
418
419 if (!File->umbrellas().empty())
420 ParentUmbrella = File->umbrellas().begin()->second;
421
422 std::set<ArchitectureSet> ArchSet;
423 for (const auto &Library : File->allowableClients())
424 ArchSet.insert(Library.getArchitectures());
425
426 for (const auto &Library : File->reexportedLibraries())
427 ArchSet.insert(Library.getArchitectures());
428
429 std::map<const Symbol *, ArchitectureSet> SymbolToArchSet;
430 for (const auto *Symbol : File->symbols()) {
431 auto Architectures = Symbol->getArchitectures();
432 SymbolToArchSet[Symbol] = Architectures;
433 ArchSet.insert(Architectures);
434 }
435
436 for (auto Architectures : ArchSet) {
437 ExportSection Section;
438 Section.Architectures = Architectures;
439
440 for (const auto &Library : File->allowableClients())
441 if (Library.getArchitectures() == Architectures)
442 Section.AllowableClients.emplace_back(Library.getInstallName());
443
444 for (const auto &Library : File->reexportedLibraries())
445 if (Library.getArchitectures() == Architectures)
446 Section.ReexportedLibraries.emplace_back(Library.getInstallName());
447
448 for (const auto &SymArch : SymbolToArchSet) {
449 if (SymArch.second != Architectures)
450 continue;
451
452 const auto *Symbol = SymArch.first;
453 switch (Symbol->getKind()) {
454 case EncodeKind::GlobalSymbol:
455 if (Symbol->isWeakDefined())
456 Section.WeakDefSymbols.emplace_back(Symbol->getName());
457 else if (Symbol->isThreadLocalValue())
458 Section.TLVSymbols.emplace_back(Symbol->getName());
459 else
460 Section.Symbols.emplace_back(Symbol->getName());
461 break;
462 case EncodeKind::ObjectiveCClass:
463 if (File->getFileType() != FileType::TBD_V3)
464 Section.Classes.emplace_back(
465 copyString("_" + Symbol->getName().str()));
466 else
467 Section.Classes.emplace_back(Symbol->getName());
468 break;
469 case EncodeKind::ObjectiveCClassEHType:
470 if (File->getFileType() != FileType::TBD_V3)
471 Section.Symbols.emplace_back(
472 copyString("_OBJC_EHTYPE_$_" + Symbol->getName().str()));
473 else
474 Section.ClassEHs.emplace_back(Symbol->getName());
475 break;
476 case EncodeKind::ObjectiveCInstanceVariable:
477 if (File->getFileType() != FileType::TBD_V3)
478 Section.IVars.emplace_back(
479 copyString("_" + Symbol->getName().str()));
480 else
481 Section.IVars.emplace_back(Symbol->getName());
482 break;
483 }
484 }
485 llvm::sort(Section.Symbols);
486 llvm::sort(Section.Classes);
487 llvm::sort(Section.ClassEHs);
488 llvm::sort(Section.IVars);
489 llvm::sort(Section.WeakDefSymbols);
490 llvm::sort(Section.TLVSymbols);
491 Exports.emplace_back(std::move(Section));
492 }
493
494 ArchSet.clear();
495 SymbolToArchSet.clear();
496
497 for (const auto *Symbol : File->undefineds()) {
498 auto Architectures = Symbol->getArchitectures();
499 SymbolToArchSet[Symbol] = Architectures;
500 ArchSet.insert(Architectures);
501 }
502
503 for (auto Architectures : ArchSet) {
504 UndefinedSection Section;
505 Section.Architectures = Architectures;
506
507 for (const auto &SymArch : SymbolToArchSet) {
508 if (SymArch.second != Architectures)
509 continue;
510
511 const auto *Symbol = SymArch.first;
512 switch (Symbol->getKind()) {
513 case EncodeKind::GlobalSymbol:
515 Section.WeakRefSymbols.emplace_back(Symbol->getName());
516 else
517 Section.Symbols.emplace_back(Symbol->getName());
518 break;
519 case EncodeKind::ObjectiveCClass:
520 if (File->getFileType() != FileType::TBD_V3)
521 Section.Classes.emplace_back(
522 copyString("_" + Symbol->getName().str()));
523 else
524 Section.Classes.emplace_back(Symbol->getName());
525 break;
526 case EncodeKind::ObjectiveCClassEHType:
527 if (File->getFileType() != FileType::TBD_V3)
528 Section.Symbols.emplace_back(
529 copyString("_OBJC_EHTYPE_$_" + Symbol->getName().str()));
530 else
531 Section.ClassEHs.emplace_back(Symbol->getName());
532 break;
533 case EncodeKind::ObjectiveCInstanceVariable:
534 if (File->getFileType() != FileType::TBD_V3)
535 Section.IVars.emplace_back(
536 copyString("_" + Symbol->getName().str()));
537 else
538 Section.IVars.emplace_back(Symbol->getName());
539 break;
540 }
541 }
542 llvm::sort(Section.Symbols);
543 llvm::sort(Section.Classes);
544 llvm::sort(Section.ClassEHs);
545 llvm::sort(Section.IVars);
546 llvm::sort(Section.WeakRefSymbols);
547 Undefineds.emplace_back(std::move(Section));
548 }
549 }
550
551 // TBD v1 - TBD v3 files only support one platform and several
552 // architectures. It is possible to have more than one platform for TBD v3
553 // files, but the architectures don't apply to all
554 // platforms, specifically to filter out the i386 slice from
555 // platform macCatalyst.
557 const PlatformSet &Platforms) {
558 TargetList Targets;
559
560 for (auto Platform : Platforms) {
561 Platform = mapToPlatformType(Platform, Architectures.hasX86());
562
563 for (const auto &&Architecture : Architectures) {
564 if ((Architecture == AK_i386) && (Platform == PLATFORM_MACCATALYST))
565 continue;
566
567 Targets.emplace_back(Architecture, Platform);
568 }
569 }
570 return Targets;
571 }
572
573 const InterfaceFile *denormalize(IO &IO) {
574 auto Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
575 assert(Ctx);
576
577 auto *File = new InterfaceFile;
578 File->setPath(Ctx->Path);
579 File->setFileType(Ctx->FileKind);
580 File->addTargets(synthesizeTargets(Architectures, Platforms));
581 File->setInstallName(InstallName);
582 File->setCurrentVersion(CurrentVersion);
583 File->setCompatibilityVersion(CompatibilityVersion);
584 File->setSwiftABIVersion(SwiftABIVersion);
585 File->setObjCConstraint(ObjCConstraint);
586 for (const auto &Target : File->targets())
587 File->addParentUmbrella(Target, ParentUmbrella);
588
589 if (Ctx->FileKind == FileType::TBD_V1) {
590 File->setTwoLevelNamespace();
591 File->setApplicationExtensionSafe();
592 } else {
593 File->setTwoLevelNamespace(!(Flags & TBDFlags::FlatNamespace));
594 File->setApplicationExtensionSafe(
595 !(Flags & TBDFlags::NotApplicationExtensionSafe));
596 }
597
598 // For older file formats, the segment where the symbol
599 // comes from is unknown, treat all symbols as Data
600 // in these cases.
601 const auto Flags = SymbolFlags::Data;
602
603 for (const auto &Section : Exports) {
604 const auto Targets =
605 synthesizeTargets(Section.Architectures, Platforms);
606
607 for (const auto &Lib : Section.AllowableClients)
608 for (const auto &Target : Targets)
609 File->addAllowableClient(Lib, Target);
610
611 for (const auto &Lib : Section.ReexportedLibraries)
612 for (const auto &Target : Targets)
613 File->addReexportedLibrary(Lib, Target);
614
615 for (const auto &Symbol : Section.Symbols) {
616 if (Ctx->FileKind != FileType::TBD_V3 &&
617 Symbol.value.starts_with(ObjC2EHTypePrefix))
618 File->addSymbol(EncodeKind::ObjectiveCClassEHType,
619 Symbol.value.drop_front(15), Targets, Flags);
620 else
621 File->addSymbol(EncodeKind::GlobalSymbol, Symbol, Targets, Flags);
622 }
623 for (auto &Symbol : Section.Classes) {
624 auto Name = Symbol.value;
625 if (Ctx->FileKind != FileType::TBD_V3)
626 Name = Name.drop_front();
627 File->addSymbol(EncodeKind::ObjectiveCClass, Name, Targets, Flags);
628 }
629 for (auto &Symbol : Section.ClassEHs)
630 File->addSymbol(EncodeKind::ObjectiveCClassEHType, Symbol, Targets,
631 Flags);
632 for (auto &Symbol : Section.IVars) {
633 auto Name = Symbol.value;
634 if (Ctx->FileKind != FileType::TBD_V3)
635 Name = Name.drop_front();
636 File->addSymbol(EncodeKind::ObjectiveCInstanceVariable, Name, Targets,
637 Flags);
638 }
639 for (auto &Symbol : Section.WeakDefSymbols)
640 File->addSymbol(EncodeKind::GlobalSymbol, Symbol, Targets,
641 SymbolFlags::WeakDefined | Flags);
642 for (auto &Symbol : Section.TLVSymbols)
643 File->addSymbol(EncodeKind::GlobalSymbol, Symbol, Targets,
644 SymbolFlags::ThreadLocalValue | Flags);
645 }
646
647 for (const auto &Section : Undefineds) {
648 const auto Targets =
649 synthesizeTargets(Section.Architectures, Platforms);
650 for (auto &Symbol : Section.Symbols) {
651 if (Ctx->FileKind != FileType::TBD_V3 &&
652 Symbol.value.starts_with(ObjC2EHTypePrefix))
653 File->addSymbol(EncodeKind::ObjectiveCClassEHType,
654 Symbol.value.drop_front(15), Targets,
655 SymbolFlags::Undefined | Flags);
656 else
657 File->addSymbol(EncodeKind::GlobalSymbol, Symbol, Targets,
658 SymbolFlags::Undefined | Flags);
659 }
660 for (auto &Symbol : Section.Classes) {
661 auto Name = Symbol.value;
662 if (Ctx->FileKind != FileType::TBD_V3)
663 Name = Name.drop_front();
664 File->addSymbol(EncodeKind::ObjectiveCClass, Name, Targets,
665 SymbolFlags::Undefined | Flags);
666 }
667 for (auto &Symbol : Section.ClassEHs)
668 File->addSymbol(EncodeKind::ObjectiveCClassEHType, Symbol, Targets,
669 SymbolFlags::Undefined | Flags);
670 for (auto &Symbol : Section.IVars) {
671 auto Name = Symbol.value;
672 if (Ctx->FileKind != FileType::TBD_V3)
673 Name = Name.drop_front();
674 File->addSymbol(EncodeKind::ObjectiveCInstanceVariable, Name, Targets,
675 SymbolFlags::Undefined | Flags);
676 }
677 for (auto &Symbol : Section.WeakRefSymbols)
678 File->addSymbol(EncodeKind::GlobalSymbol, Symbol, Targets,
679 SymbolFlags::Undefined | SymbolFlags::WeakReferenced |
680 Flags);
681 }
682
683 return File;
684 }
685
688 if (String.empty())
689 return {};
690
691 void *Ptr = Allocator.Allocate(String.size(), 1);
692 memcpy(Ptr, String.data(), String.size());
693 return StringRef(reinterpret_cast<const char *>(Ptr), String.size());
694 }
695
696 std::vector<Architecture> Architectures;
697 std::vector<UUID> UUIDs;
702 SwiftVersion SwiftABIVersion{0};
703 ObjCConstraintType ObjCConstraint{ObjCConstraintType::None};
704 TBDFlags Flags{TBDFlags::None};
706 std::vector<ExportSection> Exports;
707 std::vector<UndefinedSection> Undefineds;
708 };
709
710 static void setFileTypeForInput(TextAPIContext *Ctx, IO &IO) {
711 if (IO.mapTag("!tapi-tbd", false))
712 Ctx->FileKind = FileType::TBD_V4;
713 else if (IO.mapTag("!tapi-tbd-v3", false))
714 Ctx->FileKind = FileType::TBD_V3;
715 else if (IO.mapTag("!tapi-tbd-v2", false))
716 Ctx->FileKind = FileType::TBD_V2;
717 else if (IO.mapTag("!tapi-tbd-v1", false) ||
718 IO.mapTag("tag:yaml.org,2002:map", false))
719 Ctx->FileKind = FileType::TBD_V1;
720 else {
721 Ctx->FileKind = FileType::Invalid;
722 return;
723 }
724 }
725
726 static void mapping(IO &IO, const InterfaceFile *&File) {
727 auto *Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
728 assert((!Ctx || !IO.outputting() ||
729 (Ctx && Ctx->FileKind != FileType::Invalid)) &&
730 "File type is not set in YAML context");
731
732 if (!IO.outputting()) {
733 setFileTypeForInput(Ctx, IO);
734 switch (Ctx->FileKind) {
735 default:
736 break;
737 case FileType::TBD_V4:
738 mapKeysToValuesV4(IO, File);
739 return;
740 case FileType::Invalid:
741 IO.setError("unsupported file type");
742 return;
743 }
744 } else {
745 // Set file type when writing.
746 switch (Ctx->FileKind) {
747 default:
748 llvm_unreachable("unexpected file type");
749 case FileType::TBD_V4:
750 mapKeysToValuesV4(IO, File);
751 return;
752 case FileType::TBD_V3:
753 IO.mapTag("!tapi-tbd-v3", true);
754 break;
755 case FileType::TBD_V2:
756 IO.mapTag("!tapi-tbd-v2", true);
757 break;
758 case FileType::TBD_V1:
759 // Don't write the tag into the .tbd file for TBD v1
760 break;
761 }
762 }
763 mapKeysToValues(Ctx->FileKind, IO, File);
764 }
765
766 using SectionList = std::vector<SymbolSection>;
767 struct NormalizedTBD_V4 {
768 explicit NormalizedTBD_V4(IO &IO) {}
769 NormalizedTBD_V4(IO &IO, const InterfaceFile *&File) {
770 auto Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
771 assert(Ctx);
772 TBDVersion = Ctx->FileKind >> 4;
773 Targets.insert(Targets.begin(), File->targets().begin(),
774 File->targets().end());
775 InstallName = File->getInstallName();
776 CurrentVersion = File->getCurrentVersion();
777 CompatibilityVersion = File->getCompatibilityVersion();
778 SwiftABIVersion = File->getSwiftABIVersion();
779
780 Flags = TBDFlags::None;
781 if (!File->isApplicationExtensionSafe())
782 Flags |= TBDFlags::NotApplicationExtensionSafe;
783
784 if (!File->isTwoLevelNamespace())
785 Flags |= TBDFlags::FlatNamespace;
786
787 if (File->isOSLibNotForSharedCache())
788 Flags |= TBDFlags::OSLibNotForSharedCache;
789
790 {
791 std::map<std::string, TargetList> valueToTargetList;
792 for (const auto &it : File->umbrellas())
793 valueToTargetList[it.second].emplace_back(it.first);
794
795 for (const auto &it : valueToTargetList) {
796 UmbrellaSection CurrentSection;
797 CurrentSection.Targets.insert(CurrentSection.Targets.begin(),
798 it.second.begin(), it.second.end());
799 CurrentSection.Umbrella = it.first;
800 ParentUmbrellas.emplace_back(std::move(CurrentSection));
801 }
802 }
803
804 assignTargetsToLibrary(File->allowableClients(), AllowableClients);
805 assignTargetsToLibrary(File->reexportedLibraries(), ReexportedLibraries);
806
807 auto handleSymbols =
808 [](SectionList &CurrentSections,
810 std::set<TargetList> TargetSet;
811 std::map<const Symbol *, TargetList> SymbolToTargetList;
812 for (const auto *Symbol : Symbols) {
813 TargetList Targets(Symbol->targets());
814 SymbolToTargetList[Symbol] = Targets;
815 TargetSet.emplace(std::move(Targets));
816 }
817 for (const auto &TargetIDs : TargetSet) {
818 SymbolSection CurrentSection;
819 CurrentSection.Targets.insert(CurrentSection.Targets.begin(),
820 TargetIDs.begin(), TargetIDs.end());
821
822 for (const auto &IT : SymbolToTargetList) {
823 if (IT.second != TargetIDs)
824 continue;
825
826 const auto *Symbol = IT.first;
827 switch (Symbol->getKind()) {
828 case EncodeKind::GlobalSymbol:
829 if (Symbol->isWeakDefined())
830 CurrentSection.WeakSymbols.emplace_back(Symbol->getName());
831 else if (Symbol->isThreadLocalValue())
832 CurrentSection.TlvSymbols.emplace_back(Symbol->getName());
833 else
834 CurrentSection.Symbols.emplace_back(Symbol->getName());
835 break;
836 case EncodeKind::ObjectiveCClass:
837 CurrentSection.Classes.emplace_back(Symbol->getName());
838 break;
839 case EncodeKind::ObjectiveCClassEHType:
840 CurrentSection.ClassEHs.emplace_back(Symbol->getName());
841 break;
842 case EncodeKind::ObjectiveCInstanceVariable:
843 CurrentSection.Ivars.emplace_back(Symbol->getName());
844 break;
845 }
846 }
847 sort(CurrentSection.Symbols);
848 sort(CurrentSection.Classes);
849 sort(CurrentSection.ClassEHs);
850 sort(CurrentSection.Ivars);
851 sort(CurrentSection.WeakSymbols);
852 sort(CurrentSection.TlvSymbols);
853 CurrentSections.emplace_back(std::move(CurrentSection));
854 }
855 };
856
857 handleSymbols(Exports, File->exports());
858 handleSymbols(Reexports, File->reexports());
859 handleSymbols(Undefineds, File->undefineds());
860 }
861
862 const InterfaceFile *denormalize(IO &IO) {
863 auto Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
864 assert(Ctx);
865
866 auto *File = new InterfaceFile;
867 File->setPath(Ctx->Path);
868 File->setFileType(Ctx->FileKind);
869 File->addTargets(Targets);
870 File->setInstallName(InstallName);
871 File->setCurrentVersion(CurrentVersion);
872 File->setCompatibilityVersion(CompatibilityVersion);
873 File->setSwiftABIVersion(SwiftABIVersion);
874 for (const auto &CurrentSection : ParentUmbrellas)
875 for (const auto &target : CurrentSection.Targets)
876 File->addParentUmbrella(target, CurrentSection.Umbrella);
877 File->setTwoLevelNamespace(!(Flags & TBDFlags::FlatNamespace));
878 File->setApplicationExtensionSafe(
879 !(Flags & TBDFlags::NotApplicationExtensionSafe));
880 File->setOSLibNotForSharedCache(
881 (Flags & TBDFlags::OSLibNotForSharedCache));
882
883 for (const auto &CurrentSection : AllowableClients) {
884 for (const auto &lib : CurrentSection.Values)
885 for (const auto &Target : CurrentSection.Targets)
886 File->addAllowableClient(lib, Target);
887 }
888
889 for (const auto &CurrentSection : ReexportedLibraries) {
890 for (const auto &Lib : CurrentSection.Values)
891 for (const auto &Target : CurrentSection.Targets)
892 File->addReexportedLibrary(Lib, Target);
893 }
894
895 auto handleSymbols = [File](const SectionList &CurrentSections,
896 SymbolFlags InputFlag = SymbolFlags::None) {
897 // For older file formats, the segment where the symbol
898 // comes from is unknown, treat all symbols as Data
899 // in these cases.
900 const SymbolFlags Flag = InputFlag | SymbolFlags::Data;
901
902 for (const auto &CurrentSection : CurrentSections) {
903 for (auto &sym : CurrentSection.Symbols)
904 File->addSymbol(EncodeKind::GlobalSymbol, sym,
905 CurrentSection.Targets, Flag);
906
907 for (auto &sym : CurrentSection.Classes)
908 File->addSymbol(EncodeKind::ObjectiveCClass, sym,
909 CurrentSection.Targets, Flag);
910
911 for (auto &sym : CurrentSection.ClassEHs)
912 File->addSymbol(EncodeKind::ObjectiveCClassEHType, sym,
913 CurrentSection.Targets, Flag);
914
915 for (auto &sym : CurrentSection.Ivars)
916 File->addSymbol(EncodeKind::ObjectiveCInstanceVariable, sym,
917 CurrentSection.Targets, Flag);
918
919 SymbolFlags SymFlag =
920 ((Flag & SymbolFlags::Undefined) == SymbolFlags::Undefined)
921 ? SymbolFlags::WeakReferenced
922 : SymbolFlags::WeakDefined;
923 for (auto &sym : CurrentSection.WeakSymbols) {
924 File->addSymbol(EncodeKind::GlobalSymbol, sym,
925 CurrentSection.Targets, Flag | SymFlag);
926 }
927
928 for (auto &sym : CurrentSection.TlvSymbols)
929 File->addSymbol(EncodeKind::GlobalSymbol, sym,
930 CurrentSection.Targets,
931 Flag | SymbolFlags::ThreadLocalValue);
932 }
933 };
934
935 handleSymbols(Exports);
936 handleSymbols(Reexports, SymbolFlags::Rexported);
937 handleSymbols(Undefineds, SymbolFlags::Undefined);
938
939 return File;
940 }
941
942 unsigned TBDVersion;
943 std::vector<UUIDv4> UUIDs;
948 SwiftVersion SwiftABIVersion{0};
949 std::vector<MetadataSection> AllowableClients;
950 std::vector<MetadataSection> ReexportedLibraries;
951 TBDFlags Flags{TBDFlags::None};
952 std::vector<UmbrellaSection> ParentUmbrellas;
956
957 private:
958 void assignTargetsToLibrary(const std::vector<InterfaceFileRef> &Libraries,
959 std::vector<MetadataSection> &Section) {
960 std::set<TargetList> targetSet;
961 std::map<const InterfaceFileRef *, TargetList> valueToTargetList;
962 for (const auto &library : Libraries) {
963 TargetList targets(library.targets());
964 valueToTargetList[&library] = targets;
965 targetSet.emplace(std::move(targets));
966 }
967
968 for (const auto &targets : targetSet) {
969 MetadataSection CurrentSection;
970 CurrentSection.Targets.insert(CurrentSection.Targets.begin(),
971 targets.begin(), targets.end());
972
973 for (const auto &it : valueToTargetList) {
974 if (it.second != targets)
975 continue;
976
977 CurrentSection.Values.emplace_back(it.first->getInstallName());
978 }
979 llvm::sort(CurrentSection.Values);
980 Section.emplace_back(std::move(CurrentSection));
981 }
982 }
983 };
984
985 static void mapKeysToValues(FileType FileKind, IO &IO,
986 const InterfaceFile *&File) {
987 MappingNormalization<NormalizedTBD, const InterfaceFile *> Keys(IO, File);
988 std::vector<UUID> EmptyUUID;
989 IO.mapRequired("archs", Keys->Architectures);
990 if (FileKind != FileType::TBD_V1)
991 IO.mapOptional("uuids", EmptyUUID);
992 IO.mapRequired("platform", Keys->Platforms);
993 if (FileKind != FileType::TBD_V1)
994 IO.mapOptional("flags", Keys->Flags, TBDFlags::None);
995 IO.mapRequired("install-name", Keys->InstallName);
996 IO.mapOptional("current-version", Keys->CurrentVersion,
997 PackedVersion(1, 0, 0));
998 IO.mapOptional("compatibility-version", Keys->CompatibilityVersion,
999 PackedVersion(1, 0, 0));
1000 if (FileKind != FileType::TBD_V3)
1001 IO.mapOptional("swift-version", Keys->SwiftABIVersion, SwiftVersion(0));
1002 else
1003 IO.mapOptional("swift-abi-version", Keys->SwiftABIVersion,
1004 SwiftVersion(0));
1005 IO.mapOptional("objc-constraint", Keys->ObjCConstraint,
1006 (FileKind == FileType::TBD_V1)
1007 ? ObjCConstraintType::None
1008 : ObjCConstraintType::Retain_Release);
1009 if (FileKind != FileType::TBD_V1)
1010 IO.mapOptional("parent-umbrella", Keys->ParentUmbrella, StringRef());
1011 IO.mapOptional("exports", Keys->Exports);
1012 if (FileKind != FileType::TBD_V1)
1013 IO.mapOptional("undefineds", Keys->Undefineds);
1014 }
1015
1016 static void mapKeysToValuesV4(IO &IO, const InterfaceFile *&File) {
1017 MappingNormalization<NormalizedTBD_V4, const InterfaceFile *> Keys(IO,
1018 File);
1019 std::vector<UUIDv4> EmptyUUID;
1020 IO.mapTag("!tapi-tbd", true);
1021 IO.mapRequired("tbd-version", Keys->TBDVersion);
1022 IO.mapRequired("targets", Keys->Targets);
1023 IO.mapOptional("uuids", EmptyUUID);
1024 IO.mapOptional("flags", Keys->Flags, TBDFlags::None);
1025 IO.mapRequired("install-name", Keys->InstallName);
1026 IO.mapOptional("current-version", Keys->CurrentVersion,
1027 PackedVersion(1, 0, 0));
1028 IO.mapOptional("compatibility-version", Keys->CompatibilityVersion,
1029 PackedVersion(1, 0, 0));
1030 IO.mapOptional("swift-abi-version", Keys->SwiftABIVersion, SwiftVersion(0));
1031 IO.mapOptional("parent-umbrella", Keys->ParentUmbrellas);
1032 auto OptionKind = MetadataSection::Option::Clients;
1033 IO.mapOptionalWithContext("allowable-clients", Keys->AllowableClients,
1034 OptionKind);
1035 OptionKind = MetadataSection::Option::Libraries;
1036 IO.mapOptionalWithContext("reexported-libraries", Keys->ReexportedLibraries,
1037 OptionKind);
1038 IO.mapOptional("exports", Keys->Exports);
1039 IO.mapOptional("reexports", Keys->Reexports);
1040 IO.mapOptional("undefineds", Keys->Undefineds);
1041 }
1042};
1043
1044template <>
1045struct DocumentListTraits<std::vector<const MachO::InterfaceFile *>> {
1046 static size_t size(IO &IO, std::vector<const MachO::InterfaceFile *> &Seq) {
1047 return Seq.size();
1048 }
1049 static const InterfaceFile *&
1050 element(IO &IO, std::vector<const InterfaceFile *> &Seq, size_t Index) {
1051 if (Index >= Seq.size())
1052 Seq.resize(Index + 1);
1053 return Seq[Index];
1054 }
1055};
1056
1057} // end namespace yaml.
1058} // namespace llvm
1059
1060static void DiagHandler(const SMDiagnostic &Diag, void *Context) {
1061 auto *File = static_cast<TextAPIContext *>(Context);
1062 SmallString<1024> Message;
1063 raw_svector_ostream S(Message);
1064
1065 SMDiagnostic NewDiag(*Diag.getSourceMgr(), Diag.getLoc(), File->Path,
1066 Diag.getLineNo(), Diag.getColumnNo(), Diag.getKind(),
1067 Diag.getMessage(), Diag.getLineContents(),
1068 Diag.getRanges(), Diag.getFixIts());
1069
1070 NewDiag.print(nullptr, S);
1071 File->ErrorMessage = ("malformed file\n" + Message).str();
1072}
1073
1075 auto TAPIFile = InputBuffer.getBuffer().trim();
1076 if (TAPIFile.starts_with("{") && TAPIFile.ends_with("}"))
1077 return FileType::TBD_V5;
1078
1079 if (!TAPIFile.ends_with("..."))
1080 return createStringError(std::errc::not_supported, "unsupported file type");
1081
1082 if (TAPIFile.starts_with("--- !tapi-tbd"))
1083 return FileType::TBD_V4;
1084
1085 if (TAPIFile.starts_with("--- !tapi-tbd-v3"))
1086 return FileType::TBD_V3;
1087
1088 if (TAPIFile.starts_with("--- !tapi-tbd-v2"))
1089 return FileType::TBD_V2;
1090
1091 if (TAPIFile.starts_with("--- !tapi-tbd-v1") ||
1092 TAPIFile.starts_with("---\narchs:"))
1093 return FileType::TBD_V1;
1094
1095 return createStringError(std::errc::not_supported, "unsupported file type");
1096}
1097
1100 TextAPIContext Ctx;
1101 Ctx.Path = std::string(InputBuffer.getBufferIdentifier());
1102 if (auto FTOrErr = canRead(InputBuffer))
1103 Ctx.FileKind = *FTOrErr;
1104 else
1105 return FTOrErr.takeError();
1106
1107 // Handle JSON Format.
1108 if (Ctx.FileKind >= FileType::TBD_V5) {
1109 auto FileOrErr = getInterfaceFileFromJSON(InputBuffer.getBuffer());
1110 if (!FileOrErr)
1111 return FileOrErr.takeError();
1112
1113 (*FileOrErr)->setPath(Ctx.Path);
1114 return std::move(*FileOrErr);
1115 }
1116 yaml::Input YAMLIn(InputBuffer.getBuffer(), &Ctx, DiagHandler, &Ctx);
1117
1118 // Fill vector with interface file objects created by parsing the YAML file.
1119 std::vector<const InterfaceFile *> Files;
1120 YAMLIn >> Files;
1121
1122 // YAMLIn dynamically allocates for Interface file and in case of error,
1123 // memory leak will occur unless wrapped around unique_ptr
1124 auto File = std::unique_ptr<InterfaceFile>(
1125 const_cast<InterfaceFile *>(Files.front()));
1126
1127 for (const InterfaceFile *FI : llvm::drop_begin(Files))
1128 File->addDocument(
1129 std::shared_ptr<InterfaceFile>(const_cast<InterfaceFile *>(FI)));
1130
1131 if (YAMLIn.error())
1132 return make_error<StringError>(Ctx.ErrorMessage, YAMLIn.error());
1133
1134 return std::move(File);
1135}
1136
1138 const FileType FileKind, bool Compact) {
1139 TextAPIContext Ctx;
1140 Ctx.Path = std::string(File.getPath());
1141
1142 // Prefer parameter for format if passed, otherwise fallback to the File
1143 // FileType.
1144 Ctx.FileKind =
1145 (FileKind == FileType::Invalid) ? File.getFileType() : FileKind;
1146
1147 // Write out in JSON format.
1148 if (Ctx.FileKind >= FileType::TBD_V5) {
1149 return serializeInterfaceFileToJSON(OS, File, Ctx.FileKind, Compact);
1150 }
1151
1152 llvm::yaml::Output YAMLOut(OS, &Ctx, /*WrapColumn=*/80);
1153
1154 std::vector<const InterfaceFile *> Files;
1155 Files.emplace_back(&File);
1156
1157 for (const auto &Document : File.documents())
1158 Files.emplace_back(Document.get());
1159
1160 // Stream out yaml.
1161 YAMLOut << Files;
1162
1163 return Error::success();
1164}
aarch64 promote const
AMDGPU promote alloca to vector or false DEBUG_TYPE to vector
static cl::opt< ITMode > IT(cl::desc("IT block support"), cl::Hidden, cl::init(DefaultIT), cl::values(clEnumValN(DefaultIT, "arm-default-it", "Generate any type of IT block"), clEnumValN(RestrictedIT, "arm-restrict-it", "Disallow complex IT blocks")))
This file defines the BumpPtrAllocator interface.
std::string Name
Basic Register Allocator
Replace intrinsics with calls to vector library
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
This file defines the SmallString class.
std::pair< llvm::MachO::Target, std::string > UUID
TBDFlags
static void DiagHandler(const SMDiagnostic &Diag, void *Context)
Definition: TextStub.cpp:1060
#define LLVM_YAML_IS_SEQUENCE_VECTOR(type)
#define LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(type)
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:337
Tagged union holding either a T or a Error.
Definition: Error.h:481
Defines the interface file.
bool isWeakDefined() const
Definition: Symbol.h:109
const_target_range targets() const
Definition: Symbol.h:148
bool isThreadLocalValue() const
Definition: Symbol.h:117
ArchitectureSet getArchitectures() const
Definition: Symbol.h:104
StringRef getName() const
Definition: Symbol.h:103
EncodeKind getKind() const
Definition: Symbol.h:102
bool isWeakReferenced() const
Definition: Symbol.h:113
static llvm::Expected< Target > create(StringRef Target)
Definition: Target.cpp:17
static Expected< FileType > canRead(MemoryBufferRef InputBuffer)
Determine whether input can be interpreted as TAPI text file.
Definition: TextStub.cpp:1074
static Expected< std::unique_ptr< InterfaceFile > > get(MemoryBufferRef InputBuffer)
Parse and get an InterfaceFile that represents the full library.
Definition: TextStub.cpp:1099
static Error writeToStream(raw_ostream &OS, const InterfaceFile &File, const FileType FileKind=FileType::Invalid, bool Compact=false)
Write TAPI text file contents into stream.
Definition: TextStub.cpp:1137
StringRef getBufferIdentifier() const
StringRef getBuffer() const
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Definition: SourceMgr.h:281
void print(const char *ProgName, raw_ostream &S, bool ShowColors=true, bool ShowKindLabel=true, bool ShowLocation=true) const
Definition: SourceMgr.cpp:484
SourceMgr::DiagKind getKind() const
Definition: SourceMgr.h:310
int getLineNo() const
Definition: SourceMgr.h:308
StringRef getLineContents() const
Definition: SourceMgr.h:312
SMLoc getLoc() const
Definition: SourceMgr.h:306
StringRef getMessage() const
Definition: SourceMgr.h:311
ArrayRef< SMFixIt > getFixIts() const
Definition: SourceMgr.h:317
ArrayRef< std::pair< unsigned, unsigned > > getRanges() const
Definition: SourceMgr.h:313
const SourceMgr * getSourceMgr() const
Definition: SourceMgr.h:305
int getColumnNo() const
Definition: SourceMgr.h:309
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:135
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:951
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:819
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:215
StringRef trim(char Char) const
Return string with consecutive Char characters starting from the left and right removed.
Definition: StringRef.h:800
Target - Wrapper for Target specific information.
LLVM Value Representation.
Definition: Value.h:74
A range adaptor for a pair of iterators.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:691
A YAML Stream is a sequence of Documents.
Definition: YAMLParser.h:536
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
FileType
Defines the file type TextAPI files can represent.
Definition: FileTypes.h:15
@ Invalid
Invalid file type.
Definition: FileTypes.h:17
@ TBD_V1
Text-based stub file (.tbd) version 1.0.
Definition: FileTypes.h:29
@ TBD_V3
Text-based stub file (.tbd) version 3.0.
Definition: FileTypes.h:35
@ TBD_V5
Text-based stub file (.tbd) version 5.0.
Definition: FileTypes.h:41
@ TBD_V4
Text-based stub file (.tbd) version 4.0.
Definition: FileTypes.h:38
@ TBD_V2
Text-based stub file (.tbd) version 2.0.
Definition: FileTypes.h:32
Error serializeInterfaceFileToJSON(raw_ostream &OS, const InterfaceFile &File, const FileType FileKind, bool Compact)
ObjCConstraintType
Defines a list of Objective-C constraints.
Definition: InterfaceFile.h:34
Architecture
Defines the architecture slices that are supported by Text-based Stub files.
Definition: Architecture.h:27
PlatformType mapToPlatformType(PlatformType Platform, bool WantSim)
Definition: Platform.cpp:21
Expected< std::unique_ptr< InterfaceFile > > getInterfaceFileFromJSON(StringRef JSON)
Definition: TextStubV5.cpp:709
SymbolFlags
Symbol flags.
Definition: Symbol.h:24
constexpr StringLiteral ObjC2EHTypePrefix
Definition: Symbol.h:65
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
Definition: STLExtras.h:329
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1286
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1647
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1069
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
static const InterfaceFile *& element(IO &IO, std::vector< const InterfaceFile * > &Seq, size_t Index)
Definition: TextStub.cpp:1050
static size_t size(IO &IO, std::vector< const MachO::InterfaceFile * > &Seq)
Definition: TextStub.cpp:1046
static void mapping(IO &IO, MetadataSection &Section, MetadataSection::Option &OptionKind)
Definition: TextStub.cpp:342
static void mapping(IO &IO, ExportSection &Section)
Definition: TextStub.cpp:277
static void mapping(IO &IO, SymbolSection &Section)
Definition: TextStub.cpp:315
static void mapping(IO &IO, UUIDv4 &UUID)
Definition: TextStub.cpp:334
static void mapping(IO &IO, UmbrellaSection &Section)
Definition: TextStub.cpp:327
static void mapping(IO &IO, UndefinedSection &Section)
Definition: TextStub.cpp:299
TargetList synthesizeTargets(ArchitectureSet Architectures, const PlatformSet &Platforms)
Definition: TextStub.cpp:556
static void mapKeysToValuesV4(IO &IO, const InterfaceFile *&File)
Definition: TextStub.cpp:1016
static void setFileTypeForInput(TextAPIContext *Ctx, IO &IO)
Definition: TextStub.cpp:710
static void mapping(IO &IO, const InterfaceFile *&File)
Definition: TextStub.cpp:726
static void mapKeysToValues(FileType FileKind, IO &IO, const InterfaceFile *&File)
Definition: TextStub.cpp:985
static void bitset(IO &IO, TBDFlags &Flags)
Definition: TextStub.cpp:358
static StringRef input(StringRef Scalar, void *, Target &Value)
Definition: TextStub.cpp:381
static void output(const Target &Value, void *, raw_ostream &OS)
Definition: TextStub.cpp:369
static QuotingType mustQuote(StringRef)
Definition: TextStub.cpp:397