aboutsummaryrefslogtreecommitdiff
path: root/lib/TextAPI
diff options
context:
space:
mode:
Diffstat (limited to 'lib/TextAPI')
-rw-r--r--lib/TextAPI/MachO/Architecture.cpp4
-rw-r--r--lib/TextAPI/MachO/InterfaceFile.cpp80
-rw-r--r--lib/TextAPI/MachO/Platform.cpp91
-rw-r--r--lib/TextAPI/MachO/Symbol.cpp9
-rw-r--r--lib/TextAPI/MachO/Target.cpp75
-rw-r--r--lib/TextAPI/MachO/TextStub.cpp606
-rw-r--r--lib/TextAPI/MachO/TextStubCommon.cpp93
-rw-r--r--lib/TextAPI/MachO/TextStubCommon.h8
8 files changed, 859 insertions, 107 deletions
diff --git a/lib/TextAPI/MachO/Architecture.cpp b/lib/TextAPI/MachO/Architecture.cpp
index a66a982fa153..699fb5f4587a 100644
--- a/lib/TextAPI/MachO/Architecture.cpp
+++ b/lib/TextAPI/MachO/Architecture.cpp
@@ -68,6 +68,10 @@ std::pair<uint32_t, uint32_t> getCPUTypeFromArchitecture(Architecture Arch) {
return std::make_pair(0, 0);
}
+Architecture mapToArchitecture(const Triple &Target) {
+ return getArchitectureFromName(Target.getArchName());
+}
+
raw_ostream &operator<<(raw_ostream &OS, Architecture Arch) {
OS << getArchitectureName(Arch);
return OS;
diff --git a/lib/TextAPI/MachO/InterfaceFile.cpp b/lib/TextAPI/MachO/InterfaceFile.cpp
index 54ba8cc31267..c40a952a6a8b 100644
--- a/lib/TextAPI/MachO/InterfaceFile.cpp
+++ b/lib/TextAPI/MachO/InterfaceFile.cpp
@@ -27,36 +27,65 @@ typename C::iterator addEntry(C &Container, StringRef InstallName) {
return Container.emplace(I, InstallName);
}
+
+template <typename C>
+typename C::iterator addEntry(C &Container, const Target &Target_) {
+ auto Iter =
+ lower_bound(Container, Target_, [](const Target &LHS, const Target &RHS) {
+ return LHS < RHS;
+ });
+ if ((Iter != std::end(Container)) && !(Target_ < *Iter))
+ return Iter;
+
+ return Container.insert(Iter, Target_);
+}
} // end namespace detail.
-void InterfaceFile::addAllowableClient(StringRef Name,
- ArchitectureSet Architectures) {
- auto Client = detail::addEntry(AllowableClients, Name);
- Client->addArchitectures(Architectures);
+void InterfaceFileRef::addTarget(const Target &Target) {
+ detail::addEntry(Targets, Target);
+}
+
+void InterfaceFile::addAllowableClient(StringRef InstallName,
+ const Target &Target) {
+ auto Client = detail::addEntry(AllowableClients, InstallName);
+ Client->addTarget(Target);
}
void InterfaceFile::addReexportedLibrary(StringRef InstallName,
- ArchitectureSet Architectures) {
+ const Target &Target) {
auto Lib = detail::addEntry(ReexportedLibraries, InstallName);
- Lib->addArchitectures(Architectures);
+ Lib->addTarget(Target);
}
-void InterfaceFile::addUUID(Architecture Arch, StringRef UUID) {
- auto I = partition_point(UUIDs,
- [=](const std::pair<Architecture, std::string> &O) {
- return O.first < Arch;
- });
+void InterfaceFile::addParentUmbrella(const Target &Target_, StringRef Parent) {
+ auto Iter = lower_bound(ParentUmbrellas, Target_,
+ [](const std::pair<Target, std::string> &LHS,
+ Target RHS) { return LHS.first < RHS; });
- if (I != UUIDs.end() && Arch == I->first) {
- I->second = UUID;
+ if ((Iter != ParentUmbrellas.end()) && !(Target_ < Iter->first)) {
+ Iter->second = Parent;
return;
}
- UUIDs.emplace(I, Arch, UUID);
+ ParentUmbrellas.emplace(Iter, Target_, Parent);
return;
}
-void InterfaceFile::addUUID(Architecture Arch, uint8_t UUID[16]) {
+void InterfaceFile::addUUID(const Target &Target_, StringRef UUID) {
+ auto Iter = lower_bound(UUIDs, Target_,
+ [](const std::pair<Target, std::string> &LHS,
+ Target RHS) { return LHS.first < RHS; });
+
+ if ((Iter != UUIDs.end()) && !(Target_ < Iter->first)) {
+ Iter->second = UUID;
+ return;
+ }
+
+ UUIDs.emplace(Iter, Target_, UUID);
+ return;
+}
+
+void InterfaceFile::addUUID(const Target &Target, uint8_t UUID[16]) {
std::stringstream Stream;
for (unsigned i = 0; i < 16; ++i) {
if (i == 4 || i == 6 || i == 8 || i == 10)
@@ -64,17 +93,30 @@ void InterfaceFile::addUUID(Architecture Arch, uint8_t UUID[16]) {
Stream << std::setfill('0') << std::setw(2) << std::uppercase << std::hex
<< static_cast<int>(UUID[i]);
}
- addUUID(Arch, Stream.str());
+ addUUID(Target, Stream.str());
+}
+
+void InterfaceFile::addTarget(const Target &Target) {
+ detail::addEntry(Targets, Target);
+}
+
+InterfaceFile::const_filtered_target_range
+InterfaceFile::targets(ArchitectureSet Archs) const {
+ std::function<bool(const Target &)> fn = [Archs](const Target &Target_) {
+ return Archs.has(Target_.Arch);
+ };
+ return make_filter_range(Targets, fn);
}
void InterfaceFile::addSymbol(SymbolKind Kind, StringRef Name,
- ArchitectureSet Archs, SymbolFlags Flags) {
+ const TargetList &Targets, SymbolFlags Flags) {
Name = copyString(Name);
auto result = Symbols.try_emplace(SymbolsMapKey{Kind, Name}, nullptr);
if (result.second)
- result.first->second = new (Allocator) Symbol{Kind, Name, Archs, Flags};
+ result.first->second = new (Allocator) Symbol{Kind, Name, Targets, Flags};
else
- result.first->second->addArchitectures(Archs);
+ for (const auto &Target : Targets)
+ result.first->second->addTarget(Target);
}
} // end namespace MachO.
diff --git a/lib/TextAPI/MachO/Platform.cpp b/lib/TextAPI/MachO/Platform.cpp
new file mode 100644
index 000000000000..588ec9a4d83b
--- /dev/null
+++ b/lib/TextAPI/MachO/Platform.cpp
@@ -0,0 +1,91 @@
+//===- llvm/TextAPI/MachO/Platform.cpp - Platform ---------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementations of Platform Helper functions.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/TextAPI/MachO/Platform.h"
+
+namespace llvm {
+namespace MachO {
+
+PlatformKind mapToPlatformKind(PlatformKind Platform, bool WantSim) {
+ switch (Platform) {
+ default:
+ return Platform;
+ case PlatformKind::iOS:
+ return WantSim ? PlatformKind::iOSSimulator : PlatformKind::iOS;
+ case PlatformKind::tvOS:
+ return WantSim ? PlatformKind::tvOSSimulator : PlatformKind::tvOS;
+ case PlatformKind::watchOS:
+ return WantSim ? PlatformKind::watchOSSimulator : PlatformKind::watchOS;
+ }
+ llvm_unreachable("Unknown llvm.MachO.PlatformKind enum");
+}
+
+PlatformKind mapToPlatformKind(const Triple &Target) {
+ switch (Target.getOS()) {
+ default:
+ return PlatformKind::unknown;
+ case Triple::MacOSX:
+ return PlatformKind::macOS;
+ case Triple::IOS:
+ if (Target.isSimulatorEnvironment())
+ return PlatformKind::iOSSimulator;
+ if (Target.getEnvironment() == Triple::MacABI)
+ return PlatformKind::macCatalyst;
+ return PlatformKind::iOS;
+ case Triple::TvOS:
+ return Target.isSimulatorEnvironment() ? PlatformKind::tvOSSimulator
+ : PlatformKind::tvOS;
+ case Triple::WatchOS:
+ return Target.isSimulatorEnvironment() ? PlatformKind::watchOSSimulator
+ : PlatformKind::watchOS;
+ // TODO: add bridgeOS once in llvm::Triple
+ }
+ llvm_unreachable("Unknown Target Triple");
+}
+
+PlatformSet mapToPlatformSet(ArrayRef<Triple> Targets) {
+ PlatformSet Result;
+ for (const auto &Target : Targets)
+ Result.insert(mapToPlatformKind(Target));
+ return Result;
+}
+
+StringRef getPlatformName(PlatformKind Platform) {
+ switch (Platform) {
+ case PlatformKind::unknown:
+ return "unknown";
+ case PlatformKind::macOS:
+ return "macOS";
+ case PlatformKind::iOS:
+ return "iOS";
+ case PlatformKind::tvOS:
+ return "tvOS";
+ case PlatformKind::watchOS:
+ return "watchOS";
+ case PlatformKind::bridgeOS:
+ return "bridgeOS";
+ case PlatformKind::macCatalyst:
+ return "macCatalyst";
+ case PlatformKind::iOSSimulator:
+ return "iOS Simulator";
+ case PlatformKind::tvOSSimulator:
+ return "tvOS Simulator";
+ case PlatformKind::watchOSSimulator:
+ return "watchOS Simulator";
+ }
+ llvm_unreachable("Unknown llvm.MachO.PlatformKind enum");
+}
+
+} // end namespace MachO.
+} // end namespace llvm.
diff --git a/lib/TextAPI/MachO/Symbol.cpp b/lib/TextAPI/MachO/Symbol.cpp
index 731b264f6082..9f2d8172beed 100644
--- a/lib/TextAPI/MachO/Symbol.cpp
+++ b/lib/TextAPI/MachO/Symbol.cpp
@@ -45,5 +45,14 @@ LLVM_DUMP_METHOD void Symbol::dump(raw_ostream &OS) const {
}
#endif
+Symbol::const_filtered_target_range
+Symbol::targets(ArchitectureSet Architectures) const {
+ std::function<bool(const Target &)> FN =
+ [Architectures](const Target &Target) {
+ return Architectures.has(Target.Arch);
+ };
+ return make_filter_range(Targets, FN);
+}
+
} // end namespace MachO.
} // end namespace llvm.
diff --git a/lib/TextAPI/MachO/Target.cpp b/lib/TextAPI/MachO/Target.cpp
new file mode 100644
index 000000000000..aee8ef421425
--- /dev/null
+++ b/lib/TextAPI/MachO/Target.cpp
@@ -0,0 +1,75 @@
+//===- tapi/Core/Target.cpp - Target ----------------------------*- C++ -*-===//
+//
+// 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 "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/TextAPI/MachO/Target.h"
+
+namespace llvm {
+namespace MachO {
+
+Expected<Target> Target::create(StringRef TargetValue) {
+ auto Result = TargetValue.split('-');
+ auto ArchitectureStr = Result.first;
+ auto Architecture = getArchitectureFromName(ArchitectureStr);
+ auto PlatformStr = Result.second;
+ PlatformKind Platform;
+ Platform = StringSwitch<PlatformKind>(PlatformStr)
+ .Case("macos", PlatformKind::macOS)
+ .Case("ios", PlatformKind::iOS)
+ .Case("tvos", PlatformKind::tvOS)
+ .Case("watchos", PlatformKind::watchOS)
+ .Case("bridgeos", PlatformKind::bridgeOS)
+ .Case("maccatalyst", PlatformKind::macCatalyst)
+ .Case("ios-simulator", PlatformKind::iOSSimulator)
+ .Case("tvos-simulator", PlatformKind::tvOSSimulator)
+ .Case("watchos-simulator", PlatformKind::watchOSSimulator)
+ .Default(PlatformKind::unknown);
+
+ if (Platform == PlatformKind::unknown) {
+ if (PlatformStr.startswith("<") && PlatformStr.endswith(">")) {
+ PlatformStr = PlatformStr.drop_front().drop_back();
+ unsigned long long RawValue;
+ if (!PlatformStr.getAsInteger(10, RawValue))
+ Platform = (PlatformKind)RawValue;
+ }
+ }
+
+ return Target{Architecture, Platform};
+}
+
+Target::operator std::string() const {
+ return (getArchitectureName(Arch) + " (" + getPlatformName(Platform) + ")")
+ .str();
+}
+
+raw_ostream &operator<<(raw_ostream &OS, const Target &Target) {
+ OS << std::string(Target);
+ return OS;
+}
+
+PlatformSet mapToPlatformSet(ArrayRef<Target> Targets) {
+ PlatformSet Result;
+ for (const auto &Target : Targets)
+ Result.insert(Target.Platform);
+ return Result;
+}
+
+ArchitectureSet mapToArchitectureSet(ArrayRef<Target> Targets) {
+ ArchitectureSet Result;
+ for (const auto &Target : Targets)
+ Result.set(Target.Arch);
+ return Result;
+}
+
+} // end namespace MachO.
+} // end namespace llvm.
diff --git a/lib/TextAPI/MachO/TextStub.cpp b/lib/TextAPI/MachO/TextStub.cpp
index 799ebdc883ab..0584e43d5893 100644
--- a/lib/TextAPI/MachO/TextStub.cpp
+++ b/lib/TextAPI/MachO/TextStub.cpp
@@ -147,6 +147,58 @@ Each undefineds section is defined as following:
objc-ivars: [] # Optional: List of Objective C Instance Variables
weak-ref-symbols: [] # Optional: List of weak defined symbols
*/
+
+/*
+
+ YAML Format specification.
+
+--- !tapi-tbd
+tbd-version: 4 # The tbd version for format
+targets: [ armv7-ios, x86_64-maccatalyst ] # The list of applicable tapi supported target triples
+uuids: # Optional: List of target and UUID pairs.
+ - target: armv7-ios
+ value: ...
+ - target: x86_64-maccatalyst
+ value: ...
+flags: [] # Optional:
+install-name: /u/l/libfoo.dylib #
+current-version: 1.2.3 # Optional: defaults to 1.0
+compatibility-version: 1.0 # Optional: defaults to 1.0
+swift-abi-version: 0 # Optional: defaults to 0
+parent-umbrella: # Optional:
+allowable-clients:
+ - targets: [ armv7-ios ] # Optional:
+ clients: [ clientA ]
+exports: # List of export sections
+...
+re-exports: # List of reexport sections
+...
+undefineds: # List of undefineds sections
+...
+
+Each export and reexport section is defined as following:
+
+- targets: [ arm64-macos ] # The list of target triples associated with symbols
+ symbols: [ _symA ] # Optional: List of symbols
+ objc-classes: [] # Optional: List of Objective-C classes
+ objc-eh-types: [] # Optional: List of Objective-C classes
+ # with EH
+ objc-ivars: [] # Optional: List of Objective C Instance
+ # Variables
+ weak-symbols: [] # Optional: List of weak defined symbols
+ thread-local-symbols: [] # Optional: List of thread local symbols
+- targets: [ arm64-macos, x86_64-maccatalyst ] # Optional: Targets for applicable additional symbols
+ symbols: [ _symB ] # Optional: List of symbols
+
+Each undefineds section is defined as following:
+- targets: [ arm64-macos ] # The list of target triples associated with symbols
+ symbols: [ _symC ] # Optional: List of symbols
+ objc-classes: [] # Optional: List of Objective-C classes
+ objc-eh-types: [] # Optional: List of Objective-C classes
+ # with EH
+ objc-ivars: [] # Optional: List of Objective C Instance Variables
+ weak-symbols: [] # Optional: List of weak defined symbols
+*/
// clang-format on
using namespace llvm;
@@ -175,6 +227,38 @@ struct UndefinedSection {
std::vector<FlowStringRef> WeakRefSymbols;
};
+// Sections for direct target mapping in TBDv4
+struct SymbolSection {
+ TargetList Targets;
+ std::vector<FlowStringRef> Symbols;
+ std::vector<FlowStringRef> Classes;
+ std::vector<FlowStringRef> ClassEHs;
+ std::vector<FlowStringRef> Ivars;
+ std::vector<FlowStringRef> WeakSymbols;
+ std::vector<FlowStringRef> TlvSymbols;
+};
+
+struct MetadataSection {
+ enum Option { Clients, Libraries };
+ std::vector<Target> Targets;
+ std::vector<FlowStringRef> Values;
+};
+
+struct UmbrellaSection {
+ std::vector<Target> Targets;
+ std::string Umbrella;
+};
+
+// UUID's for TBDv4 are mapped to target not arch
+struct UUIDv4 {
+ Target TargetID;
+ std::string Value;
+
+ UUIDv4() = default;
+ UUIDv4(const Target &TargetID, const std::string &Value)
+ : TargetID(TargetID), Value(Value) {}
+};
+
// clang-format off
enum TBDFlags : unsigned {
None = 0U,
@@ -189,6 +273,12 @@ enum TBDFlags : unsigned {
LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(Architecture)
LLVM_YAML_IS_SEQUENCE_VECTOR(ExportSection)
LLVM_YAML_IS_SEQUENCE_VECTOR(UndefinedSection)
+// Specific to TBDv4
+LLVM_YAML_IS_SEQUENCE_VECTOR(SymbolSection)
+LLVM_YAML_IS_SEQUENCE_VECTOR(MetadataSection)
+LLVM_YAML_IS_SEQUENCE_VECTOR(UmbrellaSection)
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(Target)
+LLVM_YAML_IS_SEQUENCE_VECTOR(UUIDv4)
namespace llvm {
namespace yaml {
@@ -231,6 +321,49 @@ template <> struct MappingTraits<UndefinedSection> {
}
};
+template <> struct MappingTraits<SymbolSection> {
+ static void mapping(IO &IO, SymbolSection &Section) {
+ IO.mapRequired("targets", Section.Targets);
+ IO.mapOptional("symbols", Section.Symbols);
+ IO.mapOptional("objc-classes", Section.Classes);
+ IO.mapOptional("objc-eh-types", Section.ClassEHs);
+ IO.mapOptional("objc-ivars", Section.Ivars);
+ IO.mapOptional("weak-symbols", Section.WeakSymbols);
+ IO.mapOptional("thread-local-symbols", Section.TlvSymbols);
+ }
+};
+
+template <> struct MappingTraits<UmbrellaSection> {
+ static void mapping(IO &IO, UmbrellaSection &Section) {
+ IO.mapRequired("targets", Section.Targets);
+ IO.mapRequired("umbrella", Section.Umbrella);
+ }
+};
+
+template <> struct MappingTraits<UUIDv4> {
+ static void mapping(IO &IO, UUIDv4 &UUID) {
+ IO.mapRequired("target", UUID.TargetID);
+ IO.mapRequired("value", UUID.Value);
+ }
+};
+
+template <>
+struct MappingContextTraits<MetadataSection, MetadataSection::Option> {
+ static void mapping(IO &IO, MetadataSection &Section,
+ MetadataSection::Option &OptionKind) {
+ IO.mapRequired("targets", Section.Targets);
+ switch (OptionKind) {
+ case MetadataSection::Option::Clients:
+ IO.mapRequired("clients", Section.Values);
+ return;
+ case MetadataSection::Option::Libraries:
+ IO.mapRequired("libraries", Section.Values);
+ return;
+ }
+ llvm_unreachable("unexpected option for metadata");
+ }
+};
+
template <> struct ScalarBitSetTraits<TBDFlags> {
static void bitset(IO &IO, TBDFlags &Flags) {
IO.bitSetCase(Flags, "flat_namespace", TBDFlags::FlatNamespace);
@@ -240,13 +373,67 @@ template <> struct ScalarBitSetTraits<TBDFlags> {
}
};
+template <> struct ScalarTraits<Target> {
+ static void output(const Target &Value, void *, raw_ostream &OS) {
+ OS << Value.Arch << "-";
+ switch (Value.Platform) {
+ default:
+ OS << "unknown";
+ break;
+ case PlatformKind::macOS:
+ OS << "macos";
+ break;
+ case PlatformKind::iOS:
+ OS << "ios";
+ break;
+ case PlatformKind::tvOS:
+ OS << "tvos";
+ break;
+ case PlatformKind::watchOS:
+ OS << "watchos";
+ break;
+ case PlatformKind::bridgeOS:
+ OS << "bridgeos";
+ break;
+ case PlatformKind::macCatalyst:
+ OS << "maccatalyst";
+ break;
+ case PlatformKind::iOSSimulator:
+ OS << "ios-simulator";
+ break;
+ case PlatformKind::tvOSSimulator:
+ OS << "tvos-simulator";
+ break;
+ case PlatformKind::watchOSSimulator:
+ OS << "watchos-simulator";
+ break;
+ }
+ }
+
+ static StringRef input(StringRef Scalar, void *, Target &Value) {
+ auto Result = Target::create(Scalar);
+ if (!Result)
+ return toString(Result.takeError());
+
+ Value = *Result;
+ if (Value.Arch == AK_unknown)
+ return "unknown architecture";
+ if (Value.Platform == PlatformKind::unknown)
+ return "unknown platform";
+
+ return {};
+ }
+
+ static QuotingType mustQuote(StringRef) { return QuotingType::None; }
+};
+
template <> struct MappingTraits<const InterfaceFile *> {
struct NormalizedTBD {
explicit NormalizedTBD(IO &IO) {}
NormalizedTBD(IO &IO, const InterfaceFile *&File) {
Architectures = File->getArchitectures();
UUIDs = File->uuids();
- Platform = File->getPlatform();
+ Platforms = File->getPlatforms();
InstallName = File->getInstallName();
CurrentVersion = PackedVersion(File->getCurrentVersion());
CompatibilityVersion = PackedVersion(File->getCompatibilityVersion());
@@ -263,7 +450,10 @@ template <> struct MappingTraits<const InterfaceFile *> {
if (File->isInstallAPI())
Flags |= TBDFlags::InstallAPI;
- ParentUmbrella = File->getParentUmbrella();
+ for (const auto &Iter : File->umbrellas()) {
+ ParentUmbrella = Iter.second;
+ break;
+ }
std::set<ArchitectureSet> ArchSet;
for (const auto &Library : File->allowableClients())
@@ -396,6 +586,29 @@ template <> struct MappingTraits<const InterfaceFile *> {
}
}
+ // TBD v1 - TBD v3 files only support one platform and several
+ // architectures. It is possible to have more than one platform for TBD v3
+ // files, but the architectures don't apply to all
+ // platforms, specifically to filter out the i386 slice from
+ // platform macCatalyst.
+ TargetList synthesizeTargets(ArchitectureSet Architectures,
+ const PlatformSet &Platforms) {
+ TargetList Targets;
+
+ for (auto Platform : Platforms) {
+ Platform = mapToPlatformKind(Platform, Architectures.hasX86());
+
+ for (const auto &&Architecture : Architectures) {
+ if ((Architecture == AK_i386) &&
+ (Platform == PlatformKind::macCatalyst))
+ continue;
+
+ Targets.emplace_back(Architecture, Platform);
+ }
+ }
+ return Targets;
+ }
+
const InterfaceFile *denormalize(IO &IO) {
auto Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
assert(Ctx);
@@ -403,16 +616,16 @@ template <> struct MappingTraits<const InterfaceFile *> {
auto *File = new InterfaceFile;
File->setPath(Ctx->Path);
File->setFileType(Ctx->FileKind);
+ File->addTargets(synthesizeTargets(Architectures, Platforms));
for (auto &ID : UUIDs)
File->addUUID(ID.first, ID.second);
- File->setPlatform(Platform);
- File->setArchitectures(Architectures);
File->setInstallName(InstallName);
File->setCurrentVersion(CurrentVersion);
File->setCompatibilityVersion(CompatibilityVersion);
File->setSwiftABIVersion(SwiftABIVersion);
File->setObjCConstraint(ObjCConstraint);
- File->setParentUmbrella(ParentUmbrella);
+ for (const auto &Target : File->targets())
+ File->addParentUmbrella(Target, ParentUmbrella);
if (Ctx->FileKind == FileType::TBD_V1) {
File->setTwoLevelNamespace();
@@ -425,76 +638,80 @@ template <> struct MappingTraits<const InterfaceFile *> {
}
for (const auto &Section : Exports) {
- for (const auto &Library : Section.AllowableClients)
- File->addAllowableClient(Library, Section.Architectures);
- for (const auto &Library : Section.ReexportedLibraries)
- File->addReexportedLibrary(Library, Section.Architectures);
+ const auto Targets =
+ synthesizeTargets(Section.Architectures, Platforms);
+
+ for (const auto &Lib : Section.AllowableClients)
+ for (const auto &Target : Targets)
+ File->addAllowableClient(Lib, Target);
+
+ for (const auto &Lib : Section.ReexportedLibraries)
+ for (const auto &Target : Targets)
+ File->addReexportedLibrary(Lib, Target);
for (const auto &Symbol : Section.Symbols) {
if (Ctx->FileKind != FileType::TBD_V3 &&
Symbol.value.startswith("_OBJC_EHTYPE_$_"))
File->addSymbol(SymbolKind::ObjectiveCClassEHType,
- Symbol.value.drop_front(15), Section.Architectures);
+ Symbol.value.drop_front(15), Targets);
else
- File->addSymbol(SymbolKind::GlobalSymbol, Symbol,
- Section.Architectures);
+ File->addSymbol(SymbolKind::GlobalSymbol, Symbol, Targets);
}
for (auto &Symbol : Section.Classes) {
auto Name = Symbol.value;
if (Ctx->FileKind != FileType::TBD_V3)
Name = Name.drop_front();
- File->addSymbol(SymbolKind::ObjectiveCClass, Name,
- Section.Architectures);
+ File->addSymbol(SymbolKind::ObjectiveCClass, Name, Targets);
}
for (auto &Symbol : Section.ClassEHs)
- File->addSymbol(SymbolKind::ObjectiveCClassEHType, Symbol,
- Section.Architectures);
+ File->addSymbol(SymbolKind::ObjectiveCClassEHType, Symbol, Targets);
for (auto &Symbol : Section.IVars) {
auto Name = Symbol.value;
if (Ctx->FileKind != FileType::TBD_V3)
Name = Name.drop_front();
File->addSymbol(SymbolKind::ObjectiveCInstanceVariable, Name,
- Section.Architectures);
+ Targets);
}
for (auto &Symbol : Section.WeakDefSymbols)
- File->addSymbol(SymbolKind::GlobalSymbol, Symbol,
- Section.Architectures, SymbolFlags::WeakDefined);
+ File->addSymbol(SymbolKind::GlobalSymbol, Symbol, Targets,
+ SymbolFlags::WeakDefined);
for (auto &Symbol : Section.TLVSymbols)
- File->addSymbol(SymbolKind::GlobalSymbol, Symbol,
- Section.Architectures, SymbolFlags::ThreadLocalValue);
+ File->addSymbol(SymbolKind::GlobalSymbol, Symbol, Targets,
+ SymbolFlags::ThreadLocalValue);
}
for (const auto &Section : Undefineds) {
+ const auto Targets =
+ synthesizeTargets(Section.Architectures, Platforms);
for (auto &Symbol : Section.Symbols) {
if (Ctx->FileKind != FileType::TBD_V3 &&
Symbol.value.startswith("_OBJC_EHTYPE_$_"))
File->addSymbol(SymbolKind::ObjectiveCClassEHType,
- Symbol.value.drop_front(15), Section.Architectures,
+ Symbol.value.drop_front(15), Targets,
SymbolFlags::Undefined);
else
- File->addSymbol(SymbolKind::GlobalSymbol, Symbol,
- Section.Architectures, SymbolFlags::Undefined);
+ File->addSymbol(SymbolKind::GlobalSymbol, Symbol, Targets,
+ SymbolFlags::Undefined);
}
for (auto &Symbol : Section.Classes) {
auto Name = Symbol.value;
if (Ctx->FileKind != FileType::TBD_V3)
Name = Name.drop_front();
- File->addSymbol(SymbolKind::ObjectiveCClass, Name,
- Section.Architectures, SymbolFlags::Undefined);
+ File->addSymbol(SymbolKind::ObjectiveCClass, Name, Targets,
+ SymbolFlags::Undefined);
}
for (auto &Symbol : Section.ClassEHs)
- File->addSymbol(SymbolKind::ObjectiveCClassEHType, Symbol,
- Section.Architectures, SymbolFlags::Undefined);
+ File->addSymbol(SymbolKind::ObjectiveCClassEHType, Symbol, Targets,
+ SymbolFlags::Undefined);
for (auto &Symbol : Section.IVars) {
auto Name = Symbol.value;
if (Ctx->FileKind != FileType::TBD_V3)
Name = Name.drop_front();
- File->addSymbol(SymbolKind::ObjectiveCInstanceVariable, Name,
- Section.Architectures, SymbolFlags::Undefined);
+ File->addSymbol(SymbolKind::ObjectiveCInstanceVariable, Name, Targets,
+ SymbolFlags::Undefined);
}
for (auto &Symbol : Section.WeakRefSymbols)
- File->addSymbol(SymbolKind::GlobalSymbol, Symbol,
- Section.Architectures,
+ File->addSymbol(SymbolKind::GlobalSymbol, Symbol, Targets,
SymbolFlags::Undefined | SymbolFlags::WeakReferenced);
}
@@ -513,7 +730,7 @@ template <> struct MappingTraits<const InterfaceFile *> {
std::vector<Architecture> Architectures;
std::vector<UUID> UUIDs;
- PlatformKind Platform{PlatformKind::unknown};
+ PlatformSet Platforms;
StringRef InstallName;
PackedVersion CurrentVersion;
PackedVersion CompatibilityVersion;
@@ -525,71 +742,336 @@ template <> struct MappingTraits<const InterfaceFile *> {
std::vector<UndefinedSection> Undefineds;
};
+ static void setFileTypeForInput(TextAPIContext *Ctx, IO &IO) {
+ if (IO.mapTag("!tapi-tbd", false))
+ Ctx->FileKind = FileType::TBD_V4;
+ else if (IO.mapTag("!tapi-tbd-v3", false))
+ Ctx->FileKind = FileType::TBD_V3;
+ else if (IO.mapTag("!tapi-tbd-v2", false))
+ Ctx->FileKind = FileType::TBD_V2;
+ else if (IO.mapTag("!tapi-tbd-v1", false) ||
+ IO.mapTag("tag:yaml.org,2002:map", false))
+ Ctx->FileKind = FileType::TBD_V1;
+ else {
+ Ctx->FileKind = FileType::Invalid;
+ return;
+ }
+ }
+
static void mapping(IO &IO, const InterfaceFile *&File) {
auto *Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
assert((!Ctx || !IO.outputting() ||
(Ctx && Ctx->FileKind != FileType::Invalid)) &&
"File type is not set in YAML context");
- MappingNormalization<NormalizedTBD, const InterfaceFile *> Keys(IO, File);
- // prope file type when reading.
if (!IO.outputting()) {
- if (IO.mapTag("!tapi-tbd-v2", false))
- Ctx->FileKind = FileType::TBD_V2;
- else if (IO.mapTag("!tapi-tbd-v3", false))
- Ctx->FileKind = FileType::TBD_V2;
- else if (IO.mapTag("!tapi-tbd-v1", false) ||
- IO.mapTag("tag:yaml.org,2002:map", false))
- Ctx->FileKind = FileType::TBD_V1;
- else {
+ setFileTypeForInput(Ctx, IO);
+ switch (Ctx->FileKind) {
+ default:
+ break;
+ case FileType::TBD_V4:
+ mapKeysToValuesV4(IO, File);
+ return;
+ case FileType::Invalid:
IO.setError("unsupported file type");
return;
}
- }
-
- // Set file tyoe when writing.
- if (IO.outputting()) {
+ } else {
+ // Set file type when writing.
switch (Ctx->FileKind) {
default:
llvm_unreachable("unexpected file type");
- case FileType::TBD_V1:
- // Don't write the tag into the .tbd file for TBD v1.
+ case FileType::TBD_V4:
+ mapKeysToValuesV4(IO, File);
+ return;
+ case FileType::TBD_V3:
+ IO.mapTag("!tapi-tbd-v3", true);
break;
case FileType::TBD_V2:
IO.mapTag("!tapi-tbd-v2", true);
break;
- case FileType::TBD_V3:
- IO.mapTag("!tapi-tbd-v3", true);
+ case FileType::TBD_V1:
+ // Don't write the tag into the .tbd file for TBD v1
break;
}
}
+ mapKeysToValues(Ctx->FileKind, IO, File);
+ }
+
+ using SectionList = std::vector<SymbolSection>;
+ struct NormalizedTBD_V4 {
+ explicit NormalizedTBD_V4(IO &IO) {}
+ NormalizedTBD_V4(IO &IO, const InterfaceFile *&File) {
+ auto Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
+ assert(Ctx);
+ TBDVersion = Ctx->FileKind >> 1;
+ Targets.insert(Targets.begin(), File->targets().begin(),
+ File->targets().end());
+ for (const auto &IT : File->uuids())
+ UUIDs.emplace_back(IT.first, IT.second);
+ InstallName = File->getInstallName();
+ CurrentVersion = File->getCurrentVersion();
+ CompatibilityVersion = File->getCompatibilityVersion();
+ SwiftABIVersion = File->getSwiftABIVersion();
+
+ Flags = TBDFlags::None;
+ if (!File->isApplicationExtensionSafe())
+ Flags |= TBDFlags::NotApplicationExtensionSafe;
+
+ if (!File->isTwoLevelNamespace())
+ Flags |= TBDFlags::FlatNamespace;
+
+ if (File->isInstallAPI())
+ Flags |= TBDFlags::InstallAPI;
+
+ {
+ std::map<std::string, TargetList> valueToTargetList;
+ for (const auto &it : File->umbrellas())
+ valueToTargetList[it.second].emplace_back(it.first);
+
+ for (const auto &it : valueToTargetList) {
+ UmbrellaSection CurrentSection;
+ CurrentSection.Targets.insert(CurrentSection.Targets.begin(),
+ it.second.begin(), it.second.end());
+ CurrentSection.Umbrella = it.first;
+ ParentUmbrellas.emplace_back(std::move(CurrentSection));
+ }
+ }
+
+ assignTargetsToLibrary(File->allowableClients(), AllowableClients);
+ assignTargetsToLibrary(File->reexportedLibraries(), ReexportedLibraries);
+
+ auto handleSymbols =
+ [](SectionList &CurrentSections,
+ InterfaceFile::const_filtered_symbol_range Symbols,
+ std::function<bool(const Symbol *)> Pred) {
+ std::set<TargetList> TargetSet;
+ std::map<const Symbol *, TargetList> SymbolToTargetList;
+ for (const auto *Symbol : Symbols) {
+ if (!Pred(Symbol))
+ continue;
+ TargetList Targets(Symbol->targets());
+ SymbolToTargetList[Symbol] = Targets;
+ TargetSet.emplace(std::move(Targets));
+ }
+ for (const auto &TargetIDs : TargetSet) {
+ SymbolSection CurrentSection;
+ CurrentSection.Targets.insert(CurrentSection.Targets.begin(),
+ TargetIDs.begin(), TargetIDs.end());
+
+ for (const auto &IT : SymbolToTargetList) {
+ if (IT.second != TargetIDs)
+ continue;
+
+ const auto *Symbol = IT.first;
+ switch (Symbol->getKind()) {
+ case SymbolKind::GlobalSymbol:
+ if (Symbol->isWeakDefined())
+ CurrentSection.WeakSymbols.emplace_back(Symbol->getName());
+ else if (Symbol->isThreadLocalValue())
+ CurrentSection.TlvSymbols.emplace_back(Symbol->getName());
+ else
+ CurrentSection.Symbols.emplace_back(Symbol->getName());
+ break;
+ case SymbolKind::ObjectiveCClass:
+ CurrentSection.Classes.emplace_back(Symbol->getName());
+ break;
+ case SymbolKind::ObjectiveCClassEHType:
+ CurrentSection.ClassEHs.emplace_back(Symbol->getName());
+ break;
+ case SymbolKind::ObjectiveCInstanceVariable:
+ CurrentSection.Ivars.emplace_back(Symbol->getName());
+ break;
+ }
+ }
+ sort(CurrentSection.Symbols);
+ sort(CurrentSection.Classes);
+ sort(CurrentSection.ClassEHs);
+ sort(CurrentSection.Ivars);
+ sort(CurrentSection.WeakSymbols);
+ sort(CurrentSection.TlvSymbols);
+ CurrentSections.emplace_back(std::move(CurrentSection));
+ }
+ };
+
+ handleSymbols(Exports, File->exports(), [](const Symbol *Symbol) {
+ return !Symbol->isReexported();
+ });
+ handleSymbols(Reexports, File->exports(), [](const Symbol *Symbol) {
+ return Symbol->isReexported();
+ });
+ handleSymbols(Undefineds, File->undefineds(),
+ [](const Symbol *Symbol) { return true; });
+ }
+
+ const InterfaceFile *denormalize(IO &IO) {
+ auto Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
+ assert(Ctx);
+
+ auto *File = new InterfaceFile;
+ File->setPath(Ctx->Path);
+ File->setFileType(Ctx->FileKind);
+ for (auto &id : UUIDs)
+ File->addUUID(id.TargetID, id.Value);
+ File->addTargets(Targets);
+ File->setInstallName(InstallName);
+ File->setCurrentVersion(CurrentVersion);
+ File->setCompatibilityVersion(CompatibilityVersion);
+ File->setSwiftABIVersion(SwiftABIVersion);
+ for (const auto &CurrentSection : ParentUmbrellas)
+ for (const auto &target : CurrentSection.Targets)
+ File->addParentUmbrella(target, CurrentSection.Umbrella);
+ File->setTwoLevelNamespace(!(Flags & TBDFlags::FlatNamespace));
+ File->setApplicationExtensionSafe(
+ !(Flags & TBDFlags::NotApplicationExtensionSafe));
+ File->setInstallAPI(Flags & TBDFlags::InstallAPI);
+
+ for (const auto &CurrentSection : AllowableClients) {
+ for (const auto &lib : CurrentSection.Values)
+ for (const auto &Target : CurrentSection.Targets)
+ File->addAllowableClient(lib, Target);
+ }
+
+ for (const auto &CurrentSection : ReexportedLibraries) {
+ for (const auto &Lib : CurrentSection.Values)
+ for (const auto &Target : CurrentSection.Targets)
+ File->addReexportedLibrary(Lib, Target);
+ }
+
+ auto handleSymbols = [File](const SectionList &CurrentSections,
+ SymbolFlags Flag = SymbolFlags::None) {
+ for (const auto &CurrentSection : CurrentSections) {
+ for (auto &sym : CurrentSection.Symbols)
+ File->addSymbol(SymbolKind::GlobalSymbol, sym,
+ CurrentSection.Targets, Flag);
+
+ for (auto &sym : CurrentSection.Classes)
+ File->addSymbol(SymbolKind::ObjectiveCClass, sym,
+ CurrentSection.Targets);
+
+ for (auto &sym : CurrentSection.ClassEHs)
+ File->addSymbol(SymbolKind::ObjectiveCClassEHType, sym,
+ CurrentSection.Targets);
+
+ for (auto &sym : CurrentSection.Ivars)
+ File->addSymbol(SymbolKind::ObjectiveCInstanceVariable, sym,
+ CurrentSection.Targets);
+
+ for (auto &sym : CurrentSection.WeakSymbols)
+ File->addSymbol(SymbolKind::GlobalSymbol, sym,
+ CurrentSection.Targets);
+ for (auto &sym : CurrentSection.TlvSymbols)
+ File->addSymbol(SymbolKind::GlobalSymbol, sym,
+ CurrentSection.Targets,
+ SymbolFlags::ThreadLocalValue);
+ }
+ };
+
+ handleSymbols(Exports);
+ handleSymbols(Reexports, SymbolFlags::Rexported);
+ handleSymbols(Undefineds, SymbolFlags::Undefined);
+
+ return File;
+ }
+
+ unsigned TBDVersion;
+ std::vector<UUIDv4> UUIDs;
+ TargetList Targets;
+ StringRef InstallName;
+ PackedVersion CurrentVersion;
+ PackedVersion CompatibilityVersion;
+ SwiftVersion SwiftABIVersion{0};
+ std::vector<MetadataSection> AllowableClients;
+ std::vector<MetadataSection> ReexportedLibraries;
+ TBDFlags Flags{TBDFlags::None};
+ std::vector<UmbrellaSection> ParentUmbrellas;
+ SectionList Exports;
+ SectionList Reexports;
+ SectionList Undefineds;
+
+ private:
+ void assignTargetsToLibrary(const std::vector<InterfaceFileRef> &Libraries,
+ std::vector<MetadataSection> &Section) {
+ std::set<TargetList> targetSet;
+ std::map<const InterfaceFileRef *, TargetList> valueToTargetList;
+ for (const auto &library : Libraries) {
+ TargetList targets(library.targets());
+ valueToTargetList[&library] = targets;
+ targetSet.emplace(std::move(targets));
+ }
+
+ for (const auto &targets : targetSet) {
+ MetadataSection CurrentSection;
+ CurrentSection.Targets.insert(CurrentSection.Targets.begin(),
+ targets.begin(), targets.end());
+
+ for (const auto &it : valueToTargetList) {
+ if (it.second != targets)
+ continue;
+
+ CurrentSection.Values.emplace_back(it.first->getInstallName());
+ }
+ llvm::sort(CurrentSection.Values);
+ Section.emplace_back(std::move(CurrentSection));
+ }
+ }
+ };
+ static void mapKeysToValues(FileType FileKind, IO &IO,
+ const InterfaceFile *&File) {
+ MappingNormalization<NormalizedTBD, const InterfaceFile *> Keys(IO, File);
IO.mapRequired("archs", Keys->Architectures);
- if (Ctx->FileKind != FileType::TBD_V1)
+ if (FileKind != FileType::TBD_V1)
IO.mapOptional("uuids", Keys->UUIDs);
- IO.mapRequired("platform", Keys->Platform);
- if (Ctx->FileKind != FileType::TBD_V1)
+ IO.mapRequired("platform", Keys->Platforms);
+ if (FileKind != FileType::TBD_V1)
IO.mapOptional("flags", Keys->Flags, TBDFlags::None);
IO.mapRequired("install-name", Keys->InstallName);
IO.mapOptional("current-version", Keys->CurrentVersion,
PackedVersion(1, 0, 0));
IO.mapOptional("compatibility-version", Keys->CompatibilityVersion,
PackedVersion(1, 0, 0));
- if (Ctx->FileKind != FileType::TBD_V3)
+ if (FileKind != FileType::TBD_V3)
IO.mapOptional("swift-version", Keys->SwiftABIVersion, SwiftVersion(0));
else
IO.mapOptional("swift-abi-version", Keys->SwiftABIVersion,
SwiftVersion(0));
IO.mapOptional("objc-constraint", Keys->ObjCConstraint,
- (Ctx->FileKind == FileType::TBD_V1)
+ (FileKind == FileType::TBD_V1)
? ObjCConstraintType::None
: ObjCConstraintType::Retain_Release);
- if (Ctx->FileKind != FileType::TBD_V1)
+ if (FileKind != FileType::TBD_V1)
IO.mapOptional("parent-umbrella", Keys->ParentUmbrella, StringRef());
IO.mapOptional("exports", Keys->Exports);
- if (Ctx->FileKind != FileType::TBD_V1)
+ if (FileKind != FileType::TBD_V1)
IO.mapOptional("undefineds", Keys->Undefineds);
}
+
+ static void mapKeysToValuesV4(IO &IO, const InterfaceFile *&File) {
+ MappingNormalization<NormalizedTBD_V4, const InterfaceFile *> Keys(IO,
+ File);
+ IO.mapTag("!tapi-tbd", true);
+ IO.mapRequired("tbd-version", Keys->TBDVersion);
+ IO.mapRequired("targets", Keys->Targets);
+ IO.mapOptional("uuids", Keys->UUIDs);
+ IO.mapOptional("flags", Keys->Flags, TBDFlags::None);
+ IO.mapRequired("install-name", Keys->InstallName);
+ IO.mapOptional("current-version", Keys->CurrentVersion,
+ PackedVersion(1, 0, 0));
+ IO.mapOptional("compatibility-version", Keys->CompatibilityVersion,
+ PackedVersion(1, 0, 0));
+ IO.mapOptional("swift-abi-version", Keys->SwiftABIVersion, SwiftVersion(0));
+ IO.mapOptional("parent-umbrella", Keys->ParentUmbrellas);
+ auto OptionKind = MetadataSection::Option::Clients;
+ IO.mapOptionalWithContext("allowable-clients", Keys->AllowableClients,
+ OptionKind);
+ OptionKind = MetadataSection::Option::Libraries;
+ IO.mapOptionalWithContext("reexported-libraries", Keys->ReexportedLibraries,
+ OptionKind);
+ IO.mapOptional("exports", Keys->Exports);
+ IO.mapOptional("reexports", Keys->Reexports);
+ IO.mapOptional("undefineds", Keys->Undefineds);
+ }
};
template <>
@@ -623,15 +1105,17 @@ static void DiagHandler(const SMDiagnostic &Diag, void *Context) {
}
Expected<std::unique_ptr<InterfaceFile>>
-TextAPIReader::get(std::unique_ptr<MemoryBuffer> InputBuffer) {
+TextAPIReader::get(MemoryBufferRef InputBuffer) {
TextAPIContext Ctx;
- Ctx.Path = InputBuffer->getBufferIdentifier();
- yaml::Input YAMLIn(InputBuffer->getBuffer(), &Ctx, DiagHandler, &Ctx);
+ Ctx.Path = InputBuffer.getBufferIdentifier();
+ yaml::Input YAMLIn(InputBuffer.getBuffer(), &Ctx, DiagHandler, &Ctx);
// Fill vector with interface file objects created by parsing the YAML file.
std::vector<const InterfaceFile *> Files;
YAMLIn >> Files;
+ // YAMLIn dynamically allocates for Interface file and in case of error,
+ // memory leak will occur unless wrapped around unique_ptr
auto File = std::unique_ptr<InterfaceFile>(
const_cast<InterfaceFile *>(Files.front()));
diff --git a/lib/TextAPI/MachO/TextStubCommon.cpp b/lib/TextAPI/MachO/TextStubCommon.cpp
index 00382cd24573..183c5d5a93b0 100644
--- a/lib/TextAPI/MachO/TextStubCommon.cpp
+++ b/lib/TextAPI/MachO/TextStubCommon.cpp
@@ -41,9 +41,21 @@ void ScalarEnumerationTraits<ObjCConstraintType>::enumeration(
IO.enumCase(Constraint, "gc", ObjCConstraintType::GC);
}
-void ScalarTraits<PlatformKind>::output(const PlatformKind &Value, void *,
- raw_ostream &OS) {
- switch (Value) {
+void ScalarTraits<PlatformSet>::output(const PlatformSet &Values, void *IO,
+ raw_ostream &OS) {
+
+ const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO);
+ assert((!Ctx || Ctx->FileKind != FileType::Invalid) &&
+ "File type is not set in context");
+
+ if (Ctx && Ctx->FileKind == TBD_V3 && Values.count(PlatformKind::macOS) &&
+ Values.count(PlatformKind::macCatalyst)) {
+ OS << "zippered";
+ return;
+ }
+
+ assert(Values.size() == 1U);
+ switch (*Values.begin()) {
default:
llvm_unreachable("unexpected platform");
break;
@@ -64,21 +76,44 @@ void ScalarTraits<PlatformKind>::output(const PlatformKind &Value, void *,
break;
}
}
-StringRef ScalarTraits<PlatformKind>::input(StringRef Scalar, void *,
- PlatformKind &Value) {
- Value = StringSwitch<PlatformKind>(Scalar)
- .Case("macosx", PlatformKind::macOS)
- .Case("ios", PlatformKind::iOS)
- .Case("watchos", PlatformKind::watchOS)
- .Case("tvos", PlatformKind::tvOS)
- .Case("bridgeos", PlatformKind::bridgeOS)
- .Default(PlatformKind::unknown);
-
- if (Value == PlatformKind::unknown)
+
+StringRef ScalarTraits<PlatformSet>::input(StringRef Scalar, void *IO,
+ PlatformSet &Values) {
+ const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO);
+ assert((!Ctx || Ctx->FileKind != FileType::Invalid) &&
+ "File type is not set in context");
+
+ if (Scalar == "zippered") {
+ if (Ctx && Ctx->FileKind == FileType::TBD_V3) {
+ Values.insert(PlatformKind::macOS);
+ Values.insert(PlatformKind::macCatalyst);
+ return {};
+ }
+ return "invalid platform";
+ }
+
+ auto Platform = StringSwitch<PlatformKind>(Scalar)
+ .Case("unknown", PlatformKind::unknown)
+ .Case("macosx", PlatformKind::macOS)
+ .Case("ios", PlatformKind::iOS)
+ .Case("watchos", PlatformKind::watchOS)
+ .Case("tvos", PlatformKind::tvOS)
+ .Case("bridgeos", PlatformKind::bridgeOS)
+ .Case("iosmac", PlatformKind::macCatalyst)
+ .Default(PlatformKind::unknown);
+
+ if (Platform == PlatformKind::macCatalyst)
+ if (Ctx && Ctx->FileKind != FileType::TBD_V3)
+ return "invalid platform";
+
+ if (Platform == PlatformKind::unknown)
return "unknown platform";
+
+ Values.insert(Platform);
return {};
}
-QuotingType ScalarTraits<PlatformKind>::mustQuote(StringRef) {
+
+QuotingType ScalarTraits<PlatformSet>::mustQuote(StringRef) {
return QuotingType::None;
}
@@ -137,14 +172,25 @@ void ScalarTraits<SwiftVersion>::output(const SwiftVersion &Value, void *,
break;
}
}
-StringRef ScalarTraits<SwiftVersion>::input(StringRef Scalar, void *,
+StringRef ScalarTraits<SwiftVersion>::input(StringRef Scalar, void *IO,
SwiftVersion &Value) {
- Value = StringSwitch<SwiftVersion>(Scalar)
- .Case("1.0", 1)
- .Case("1.1", 2)
- .Case("2.0", 3)
- .Case("3.0", 4)
- .Default(0);
+ const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO);
+ assert((!Ctx || Ctx->FileKind != FileType::Invalid) &&
+ "File type is not set in context");
+
+ if (Ctx->FileKind == FileType::TBD_V4) {
+ if (Scalar.getAsInteger(10, Value))
+ return "invalid Swift ABI version.";
+ return {};
+ } else {
+ Value = StringSwitch<SwiftVersion>(Scalar)
+ .Case("1.0", 1)
+ .Case("1.1", 2)
+ .Case("2.0", 3)
+ .Case("3.0", 4)
+ .Default(0);
+ }
+
if (Value != SwiftVersion(0))
return {};
@@ -166,10 +212,11 @@ StringRef ScalarTraits<UUID>::input(StringRef Scalar, void *, UUID &Value) {
auto UUID = Split.second.trim();
if (UUID.empty())
return "invalid uuid string pair";
- Value.first = getArchitectureFromName(Arch);
Value.second = UUID;
+ Value.first = Target{getArchitectureFromName(Arch), PlatformKind::unknown};
return {};
}
+
QuotingType ScalarTraits<UUID>::mustQuote(StringRef) {
return QuotingType::Single;
}
diff --git a/lib/TextAPI/MachO/TextStubCommon.h b/lib/TextAPI/MachO/TextStubCommon.h
index c4dd1075b1c8..a558cbcec9fb 100644
--- a/lib/TextAPI/MachO/TextStubCommon.h
+++ b/lib/TextAPI/MachO/TextStubCommon.h
@@ -21,7 +21,7 @@
#include "llvm/TextAPI/MachO/InterfaceFile.h"
#include "llvm/TextAPI/MachO/PackedVersion.h"
-using UUID = std::pair<llvm::MachO::Architecture, std::string>;
+using UUID = std::pair<llvm::MachO::Target, std::string>;
LLVM_YAML_STRONG_TYPEDEF(llvm::StringRef, FlowStringRef)
LLVM_YAML_STRONG_TYPEDEF(uint8_t, SwiftVersion)
@@ -41,9 +41,9 @@ template <> struct ScalarEnumerationTraits<MachO::ObjCConstraintType> {
static void enumeration(IO &, MachO::ObjCConstraintType &);
};
-template <> struct ScalarTraits<MachO::PlatformKind> {
- static void output(const MachO::PlatformKind &, void *, raw_ostream &);
- static StringRef input(StringRef, void *, MachO::PlatformKind &);
+template <> struct ScalarTraits<MachO::PlatformSet> {
+ static void output(const MachO::PlatformSet &, void *, raw_ostream &);
+ static StringRef input(StringRef, void *, MachO::PlatformSet &);
static QuotingType mustQuote(StringRef);
};
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-09 22:25:43 +0000