[TextAPI] Introduce TBDv4

[cishida]

Summary

This format introduces new features and platforms
The motivation for this format is to support more than 1 platform since previous versions only supported additional architectures and 1 platform,
for example ios + ios-simulator and macCatalyst.

[ributzka]

llvm/lib/TextAPI/MachO/TextStub.cpp

353

Oops, I forgot to change this to a proper enum. Could you please fix this?

[cishida]

Add enum to MetaDataSection

[ributzka]

llvm/lib/TextAPI/MachO/TextStub.cpp

740

I guess this should be called setFileTypeForInput, because this only gets called when a file is read.

1285

Please also update here with the new enum.

1287

ditto

llvm/unittests/TextAPI/TextStubV4Tests.cpp

222

Why do you use .at() here?

[cishida]

Address comments from review

[ributzka]

llvm/lib/TextAPI/MachO/TextStub.cpp

352

I don't think the context has to be an unsigned. Now that you have an enum, you can use that instead. Please also update the coder further down that sets the context.

355

The switch statement could be improved by removing the default. That way the compiler will emit a warning if the switch statement isn't fully covered. There should also be a llvm_unreachable after the switch statement to catch unexpected values.

784

nitpick: the order it quite random now.

816

Factoring this out into a separate function would make this code easier to understand, because we fall-through to this code, but call the mappingTBD_V4 method in the other case.

[cishida]

Additional Cleanup.

• Factor out mapping
• propogate MetdataOption enum

[ributzka]

llvm/unittests/TextAPI/TextStubV4Tests.cpp

309

s/macabi/maccatalyst

373

For TBD v4 the swift-abi-version should be just an integer. In this case it should be just 1.

388

And here the swift-abi-version should be 2.

[cishida]

llvm/unittests/TextAPI/TextStubV4Tests.cpp

373

for tbdv-4 should it be considered malformed to pass a float? as opposed to currently rounding

[ributzka]

llvm/unittests/TextAPI/TextStubV4Tests.cpp

373

I wouldn't call it a float. It used to be the Swift version string in previous TBD versions and now it is the Swift ABI version, which is only an integer. Passing anything else for TBD v4 should be considered malformed.

[cishida]

Update: Enforce Integer value for swift abi version

[ributzka]

llvm/include/llvm/TextAPI/MachO/Symbol.h

56

that is not very small ;-) 20 elements seem overkill for this.

[cishida]

llvm/include/llvm/TextAPI/MachO/Symbol.h

56

ill change it to 5!

[cishida]

Reduce inplace limit for TargetList

[ributzka]

llvm/lib/TextAPI/MachO/Target.cpp

35

Sorry, I just noticed that the simulators are missing in this list. Please add support for them and also matching tests.

[cishida]

Add simulator + tests

[ributzka]

Thanks Cyndy. LGTM

[cishida]

Fix a few typos in comments

llvm/include/llvm/TextAPI/MachO/InterfaceFile.h

enum FileType : unsigned {
   TBD_V1  = 1U <<  0,
 
   /// Text-based stub file (.tbd) version 2.0
   TBD_V2  = 1U <<  1,
 
   /// Text-based stub file (.tbd) version 3.0
   TBD_V3  = 1U <<  2,
 
+  /// Text-based stub file (.tbd) version 4.0
+  TBD_V4  = 1U <<  3,
+
   All     = ~0U,
 
   LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/All),
 };
 
 // clang-format on
 
 /// Reference to an interface file.

llvm/include/llvm/TextAPI/MachO/Symbol.h

enum class SymbolFlags : uint8_t {
   WeakDefined      = 1U << 1,
 
   /// Weak referenced symbol
   WeakReferenced   = 1U << 2,
 
   /// Undefined
   Undefined        = 1U << 3,
 
-  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Undefined),
+  /// Rexported
+  Rexported        = 1U << 4,
+
+  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Rexported),
 };
 
 // clang-format on
 
 enum class SymbolKind : uint8_t {
   GlobalSymbol,
   ObjectiveCClass,
   ObjectiveCClassEHType,
   ObjectiveCInstanceVariable,
 };
 
-using TargetList = SmallVector<Target, 20>;
+using TargetList = SmallVector<Target, 5>;
 class Symbol {
 public:
   Symbol(SymbolKind Kind, StringRef Name, TargetList Targets, SymbolFlags Flags)
       : Name(Name), Targets(std::move(Targets)), Kind(Kind), Flags(Flags) {}
 
   void addTarget(Target target) { Targets.emplace_back(target); }
   SymbolKind getKind() const { return Kind; }
   StringRef getName() const { return Name; }
bool isThreadLocalValue() const {
     return (Flags & SymbolFlags::ThreadLocalValue) ==
            SymbolFlags::ThreadLocalValue;
   }
 
   bool isUndefined() const {
     return (Flags & SymbolFlags::Undefined) == SymbolFlags::Undefined;
   }
 
+  bool isReexported() const {
+    return (Flags & SymbolFlags::Rexported) == SymbolFlags::Rexported;
+  }
+
   using const_target_iterator = TargetList::const_iterator;
   using const_target_range = llvm::iterator_range<const_target_iterator>;
   const_target_range targets() const { return {Targets}; }
 
   using const_filtered_target_iterator =
       llvm::filter_iterator<const_target_iterator,
                             std::function<bool(const Target &)>>;
   using const_filtered_target_range =

llvm/include/llvm/TextAPI/MachO/Target.h

 class Target {
 public:
   Target() = default;
   Target(Architecture Arch, PlatformKind Platform)
       : Arch(Arch), Platform(Platform) {}
   explicit Target(const llvm::Triple &Triple)
       : Arch(mapToArchitecture(Triple)), Platform(mapToPlatformKind(Triple)) {}
 
+  static llvm::Expected<Target> create(StringRef Target);
+
   operator std::string() const;
 
   Architecture Arch;
   PlatformKind Platform;
 };
 
 inline bool operator==(const Target &LHS, const Target &RHS) {
   return std::tie(LHS.Arch, LHS.Platform) == std::tie(RHS.Arch, RHS.Platform);

llvm/lib/TextAPI/MachO/Target.cpp

 #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);
+  if (Architecture == AK_unknown)
+    return make_error<StringError>("invalid architecture",
+                                   inconvertibleErrorCode());
+  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))
+        return make_error<StringError>("invalid platform number",
+                                       inconvertibleErrorCode());
+
+      Platform = (PlatformKind)RawValue;
+    }
+    return make_error<StringError>("invalid platform",
+                                   inconvertibleErrorCode());
+  }
+
+  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;

 ArchitectureSet mapToArchitectureSet(ArrayRef<Target> Targets) {
   ArchitectureSet Result;
   for (const auto &Target : Targets)
     Result.set(Target.Arch);
   return Result;
 }
 
 } // end namespace MachO.
-} // end namespace llvm.
+} // end namespace llvm.
 

llvm/lib/TextAPI/MachO/TextStub.cpp

 - archs: [ arm64 ]     # the list of architecture slices
   symbols: [ _sym ]    # 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-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;
 using namespace llvm::yaml;
 using namespace llvm::MachO;
 
 namespace {
 struct ExportSection {
struct UndefinedSection {
   std::vector<Architecture> Architectures;
   std::vector<FlowStringRef> Symbols;
   std::vector<FlowStringRef> Classes;
   std::vector<FlowStringRef> ClassEHs;
   std::vector<FlowStringRef> IVars;
   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,
   FlatNamespace                = 1U << 0,
   NotApplicationExtensionSafe  = 1U << 1,
   InstallAPI                   = 1U << 2,
   LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/InstallAPI),
 };
 // clang-format on
 } // end anonymous namespace.
 
 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 {
 
 template <> struct MappingTraits<ExportSection> {
   static void mapping(IO &IO, ExportSection &Section) {
     const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
     assert((!Ctx || (Ctx && Ctx->FileKind != FileType::Invalid)) &&
static void mapping(IO &IO, UndefinedSection &Section) {
     IO.mapOptional("objc-classes", Section.Classes);
     if (Ctx->FileKind == FileType::TBD_V3)
       IO.mapOptional("objc-eh-types", Section.ClassEHs);
     IO.mapOptional("objc-ivars", Section.IVars);
     IO.mapOptional("weak-ref-symbols", Section.WeakRefSymbols);
   }
 };
 
+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);
     IO.bitSetCase(Flags, "not_app_extension_safe",
                   TBDFlags::NotApplicationExtensionSafe);
     IO.bitSetCase(Flags, "installapi", TBDFlags::InstallAPI);
   }
 };
 
+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;
+    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();
       Platforms = File->getPlatforms();
       InstallName = File->getInstallName();
struct NormalizedTBD {
     SwiftVersion SwiftABIVersion{0};
     ObjCConstraintType ObjCConstraint{ObjCConstraintType::None};
     TBDFlags Flags{TBDFlags::None};
     StringRef ParentUmbrella;
     std::vector<ExportSection> Exports;
     std::vector<UndefinedSection> Undefineds;
   };
 
-  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-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 {
-        IO.setError("unsupported file type");
-        return;
-      }
-    }
+  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::Invalid;
 
+  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");
+
+    if (!IO.outputting()) {
+      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;
+      }
+    } else {
       // Set file type when writing.
-    if (IO.outputting()) {
       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();
+      SwiftVersion = File->getSwiftABIVersion();
+
+      Flags = TBDFlags::None;
+      if (!File->isApplicationExtensionSafe())
+        Flags |= TBDFlags::NotApplicationExtensionSafe;
+
+      if (!File->isTwoLevelNamespace())
+        Flags |= TBDFlags::FlatNamespace;
+
+      if (File->isInstallAPI())
+        Flags |= TBDFlags::InstallAPI;
+
+      {
+        using TargetList = SmallVector<Target, 4>;
+        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) {
+            using TargetList = SmallVector<Target, 4>;
+            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(SwiftVersion);
+      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 SwiftVersion{0};
+    std::vector<MetadataSection> AllowableClients;
+    std::vector<MetadataSection> ReexportedLibraries;
+    TBDFlags Flags{TBDFlags::None};
+    std::vector<UmbrellaSection> ParentUmbrellas;
+    SectionList Exports;
+    SectionList Reexports;
+    SectionList Undefineds;
+
+  private:
+    using TargetList = SmallVector<Target, 4>;
+    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->Platforms);
-    if (Ctx->FileKind != FileType::TBD_V1)
+    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)
-      IO.mapOptional("undefineds", Keys->Undefineds);
+    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->SwiftVersion, 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);
   }
 };
 
 template <>
 struct DocumentListTraits<std::vector<const MachO::InterfaceFile *>> {
   static size_t size(IO &IO, std::vector<const MachO::InterfaceFile *> &Seq) {
     return Seq.size();
   }
Error TextAPIWriter::writeToStream(raw_ostream &OS, const InterfaceFile &File) {
 
   // Stream out yaml.
   YAMLOut << Files;
 
   return Error::success();
 }
 
 } // end namespace MachO.
 } // end namespace llvm.

llvm/lib/TextAPI/MachO/TextStubCommon.cpp

void ScalarTraits<SwiftVersion>::output(const SwiftVersion &Value, void *,
   case 4:
     OS << "3.0";
     break;
   default:
     OS << (unsigned)Value;
     break;
   }
 }
-StringRef ScalarTraits<SwiftVersion>::input(StringRef Scalar, void *,
+StringRef ScalarTraits<SwiftVersion>::input(StringRef Scalar, void *IO,
                                             SwiftVersion &Value) {
+  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 {};
 
   if (Scalar.getAsInteger(10, Value))
     return "invalid Swift ABI version.";
 
   return StringRef();
 }

llvm/unittests/TextAPI/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   TextAPI
 )
 
 add_llvm_unittest(TextAPITests
   ELFYAMLTest.cpp
   TextStubV1Tests.cpp
   TextStubV2Tests.cpp
   TextStubV3Tests.cpp
+  TextStubV4Tests.cpp
 )
 
 target_link_libraries(TextAPITests PRIVATE LLVMTestingSupport)

llvm/unittests/TextAPI/TextStubV4Tests.cpp

+//===-- TextStubV4Tests.cpp - TBD V4 File Test ----------------------------===//
+//
+// 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/TextAPI/MachO/InterfaceFile.h"
+#include "llvm/TextAPI/MachO/TextAPIReader.h"
+#include "llvm/TextAPI/MachO/TextAPIWriter.h"
+#include "gtest/gtest.h"
+#include <string>
+#include <vector>
+
+using namespace llvm;
+using namespace llvm::MachO;
+
+struct ExampleSymbol {
+  SymbolKind Kind;
+  std::string Name;
+  bool WeakDefined;
+  bool ThreadLocalValue;
+};
+using ExampleSymbolSeq = std::vector<ExampleSymbol>;
+using UUIDs = std::vector<std::pair<Target, std::string>>;
+
+inline bool operator<(const ExampleSymbol &LHS, const ExampleSymbol &RHS) {
+  return std::tie(LHS.Kind, LHS.Name) < std::tie(RHS.Kind, RHS.Name);
+}
+
+inline bool operator==(const ExampleSymbol &LHS, const ExampleSymbol &RHS) {
+  return std::tie(LHS.Kind, LHS.Name, LHS.WeakDefined, LHS.ThreadLocalValue) ==
+         std::tie(RHS.Kind, RHS.Name, RHS.WeakDefined, RHS.ThreadLocalValue);
+}
+
+static ExampleSymbol TBDv4ExportedSymbols[] = {
+    {SymbolKind::GlobalSymbol, "_symA", false, false},
+    {SymbolKind::GlobalSymbol, "_symAB", false, false},
+    {SymbolKind::GlobalSymbol, "_symB", false, false},
+};
+
+static ExampleSymbol TBDv4ReexportedSymbols[] = {
+    {SymbolKind::GlobalSymbol, "_symC", false, false},
+};
+
+static ExampleSymbol TBDv4UndefinedSymbols[] = {
+    {SymbolKind::GlobalSymbol, "_symD", false, false},
+};
+
+namespace TBDv4 {
+
+TEST(TBDv4, ReadFile) {
+  static const char tbd_v4_file[] =
+      "--- !tapi-tbd\n"
+      "tbd-version: 4\n"
+      "targets:  [ i386-macos, x86_64-macos, x86_64-ios ]\n"
+      "uuids:\n"
+      "  - target: i386-macos\n"
+      "    value: 00000000-0000-0000-0000-000000000000\n"
+      "  - target: x86_64-macos\n"
+      "    value: 11111111-1111-1111-1111-111111111111\n"
+      "  - target: x86_64-ios\n"
+      "    value: 11111111-1111-1111-1111-111111111111\n"
+      "flags: [ flat_namespace, installapi ]\n"
+      "install-name: Umbrella.framework/Umbrella\n"
+      "current-version: 1.2.3\n"
+      "compatibility-version: 1.2\n"
+      "swift-abi-version: 5\n"
+      "parent-umbrella:\n"
+      "  - targets: [ i386-macos, x86_64-macos, x86_64-ios ]\n"
+      "    umbrella: System\n"
+      "allowable-clients:\n"
+      "  - targets: [ i386-macos, x86_64-macos, x86_64-ios ]\n"
+      "    clients: [ ClientA ]\n"
+      "reexported-libraries:\n"
+      "  - targets: [ i386-macos ]\n"
+      "    libraries: [ /System/Library/Frameworks/A.framework/A ]\n"
+      "exports:\n"
+      "  - targets: [ i386-macos ]\n"
+      "    symbols: [ _symA ]\n"
+      "    objc-classes: []\n"
+      "    objc-eh-types: []\n"
+      "    objc-ivars: []\n"
+      "    weak-symbols: []\n"
+      "    thread-local-symbols: []\n"
+      "  - targets: [ x86_64-ios ]\n"
+      "    symbols: [_symB]\n"
+      "  - targets: [ x86_64-macos, x86_64-ios ]\n"
+      "    symbols: [_symAB]\n"
+      "reexports:\n"
+      "  - targets: [ i386-macos ]\n"
+      "    symbols: [_symC]\n"
+      "    objc-classes: []\n"
+      "    objc-eh-types: []\n"
+      "    objc-ivars: []\n"
+      "    weak-symbols: []\n"
+      "    thread-local-symbols: []\n"
+      "undefineds:\n"
+      "  - targets: [ i386-macos ]\n"
+      "    symbols: [ _symD ]\n"
+      "    objc-classes: []\n"
+      "    objc-eh-types: []\n"
+      "    objc-ivars: []\n"
+      "    weak-symbols: []\n"
+      "    thread-local-symbols: []\n"
+      "...\n";
+
+  auto Result = TextAPIReader::get(MemoryBufferRef(tbd_v4_file, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V4, File->getFileType());
+  PlatformSet Platforms;
+  Platforms.insert(PlatformKind::macOS);
+  Platforms.insert(PlatformKind::iOS);
+  auto Archs = AK_i386 | AK_x86_64;
+  TargetList Targets = {
+      Target(AK_i386, PlatformKind::macOS),
+      Target(AK_x86_64, PlatformKind::macOS),
+      Target(AK_x86_64, PlatformKind::iOS),
+  };
+  UUIDs uuids = {{Targets[0], "00000000-0000-0000-0000-000000000000"},
+                 {Targets[1], "11111111-1111-1111-1111-111111111111"},
+                 {Targets[2], "11111111-1111-1111-1111-111111111111"}};
+  EXPECT_EQ(Archs, File->getArchitectures());
+  EXPECT_EQ(uuids, File->uuids());
+  EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
+  for (auto Platform : File->getPlatforms())
+    EXPECT_EQ(Platforms.count(Platform), 1U);
+  EXPECT_EQ(std::string("Umbrella.framework/Umbrella"), File->getInstallName());
+  EXPECT_EQ(PackedVersion(1, 2, 3), File->getCurrentVersion());
+  EXPECT_EQ(PackedVersion(1, 2, 0), File->getCompatibilityVersion());
+  EXPECT_EQ(5U, File->getSwiftABIVersion());
+  EXPECT_FALSE(File->isTwoLevelNamespace());
+  EXPECT_TRUE(File->isApplicationExtensionSafe());
+  EXPECT_TRUE(File->isInstallAPI());
+  InterfaceFileRef client("ClientA", Targets);
+  InterfaceFileRef reexport("/System/Library/Frameworks/A.framework/A",
+                            {Targets[0]});
+  EXPECT_EQ(1U, File->allowableClients().size());
+  EXPECT_EQ(client, File->allowableClients().front());
+  EXPECT_EQ(1U, File->reexportedLibraries().size());
+  EXPECT_EQ(reexport, File->reexportedLibraries().front());
+
+  ExampleSymbolSeq Exports, Reexports, Undefineds;
+  ExampleSymbol temp;
+  for (const auto *Sym : File->symbols()) {
+    temp = ExampleSymbol{Sym->getKind(), Sym->getName(), Sym->isWeakDefined(),
+                         Sym->isThreadLocalValue()};
+    EXPECT_FALSE(Sym->isWeakReferenced());
+    if (Sym->isUndefined())
+      Undefineds.emplace_back(std::move(temp));
+    else
+      Sym->isReexported() ? Reexports.emplace_back(std::move(temp))
+                          : Exports.emplace_back(std::move(temp));
+  }
+  llvm::sort(Exports.begin(), Exports.end());
+  llvm::sort(Reexports.begin(), Reexports.end());
+  llvm::sort(Undefineds.begin(), Undefineds.end());
+
+  EXPECT_EQ(sizeof(TBDv4ExportedSymbols) / sizeof(ExampleSymbol),
+            Exports.size());
+  EXPECT_EQ(sizeof(TBDv4ReexportedSymbols) / sizeof(ExampleSymbol),
+            Reexports.size());
+  EXPECT_EQ(sizeof(TBDv4UndefinedSymbols) / sizeof(ExampleSymbol),
+            Undefineds.size());
+  EXPECT_TRUE(std::equal(Exports.begin(), Exports.end(),
+                         std::begin(TBDv4ExportedSymbols)));
+  EXPECT_TRUE(std::equal(Reexports.begin(), Reexports.end(),
+                         std::begin(TBDv4ReexportedSymbols)));
+  EXPECT_TRUE(std::equal(Undefineds.begin(), Undefineds.end(),
+                         std::begin(TBDv4UndefinedSymbols)));
+}
+
+TEST(TBDv4, WriteFile) {
+  static const char tbd_v4_file[] =
+      "--- !tapi-tbd\n"
+      "tbd-version:     4\n"
+      "targets:         [ i386-macos, x86_64-ios-simulator ]\n"
+      "uuids:\n"
+      "  - target:          i386-macos\n"
+      "    value:           00000000-0000-0000-0000-000000000000\n"
+      "  - target:          x86_64-ios-simulator\n"
+      "    value:           11111111-1111-1111-1111-111111111111\n"
+      "flags:           [ installapi ]\n"
+      "install-name:    'Umbrella.framework/Umbrella'\n"
+      "current-version: 1.2.3\n"
+      "compatibility-version: 0\n"
+      "swift-abi-version: 5\n"
+      "parent-umbrella:\n"
+      "  - targets:         [ i386-macos, x86_64-ios-simulator ]\n"
+      "    umbrella:        System\n"
+      "allowable-clients:\n"
+      "  - targets:         [ i386-macos ]\n"
+      "    clients:         [ ClientA ]\n"
+      "exports:\n"
+      "  - targets:         [ i386-macos ]\n"
+      "    symbols:         [ _symA ]\n"
+      "    objc-classes:    [ Class1 ]\n"
+      "    weak-symbols:    [ _symC ]\n"
+      "  - targets:         [ x86_64-ios-simulator ]\n"
+      "    symbols:         [ _symB ]\n"
+      "...\n";
+
+  InterfaceFile File;
+  TargetList Targets = {
+      Target(AK_i386, PlatformKind::macOS),
+      Target(AK_x86_64, PlatformKind::iOSSimulator),
+  };
+  UUIDs uuids = {{Targets[0], "00000000-0000-0000-0000-000000000000"},
+                 {Targets[1], "11111111-1111-1111-1111-111111111111"}};
+  File.setInstallName("Umbrella.framework/Umbrella");
+  File.setFileType(FileType::TBD_V4);
+  File.addTargets(Targets);
+  File.addUUID(uuids[0].first, uuids[0].second);
+  File.addUUID(uuids[1].first, uuids[1].second);
+  File.setCurrentVersion(PackedVersion(1, 2, 3));
+  File.setTwoLevelNamespace();
+  File.setInstallAPI(true);
+  File.setApplicationExtensionSafe(true);
+  File.setSwiftABIVersion(5);
+  File.addAllowableClient("ClientA", Targets[0]);
+  File.addParentUmbrella(Targets[0], "System");
+  File.addParentUmbrella(Targets[1], "System");
+  File.addSymbol(SymbolKind::GlobalSymbol, "_symA", {Targets[0]});
+  File.addSymbol(SymbolKind::GlobalSymbol, "_symB", {Targets[1]});
+  File.addSymbol(SymbolKind::GlobalSymbol, "_symC", {Targets[0]},
+                 SymbolFlags::WeakDefined);
+  File.addSymbol(SymbolKind::ObjectiveCClass, "Class1", {Targets[0]});
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto Result = TextAPIWriter::writeToStream(OS, File);
+  EXPECT_FALSE(Result);
+  EXPECT_STREQ(tbd_v4_file, Buffer.c_str());
+}
+
+TEST(TBDv4, MultipleTargets) {
+  static const char tbd_multiple_targets[] =
+      "--- !tapi-tbd\n"
+      "tbd-version: 4\n"
+      "targets: [ i386-maccatalyst, x86_64-tvos, arm64-ios ]\n"
+      "install-name: Test.dylib\n"
+      "...\n";
+
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_multiple_targets, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  PlatformSet Platforms;
+  Platforms.insert(PlatformKind::macCatalyst);
+  Platforms.insert(PlatformKind::tvOS);
+  Platforms.insert(PlatformKind::iOS);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V4, File->getFileType());
+  EXPECT_EQ(AK_x86_64 | AK_arm64 | AK_i386, File->getArchitectures());
+  EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
+  for (auto Platform : File->getPlatforms())
+    EXPECT_EQ(Platforms.count(Platform), 1U);
+}
+
+TEST(TBDv4, MultipleTargetsSameArch) {
+  static const char tbd_targets_same_arch[] =
+      "--- !tapi-tbd\n"
+      "tbd-version: 4\n"
+      "targets: [ x86_64-maccatalyst, x86_64-tvos ]\n"
+      "install-name: Test.dylib\n"
+      "...\n";
+
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_targets_same_arch, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  PlatformSet Platforms;
+  Platforms.insert(PlatformKind::tvOS);
+  Platforms.insert(PlatformKind::macCatalyst);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V4, File->getFileType());
+  EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
+  EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
+  for (auto Platform : File->getPlatforms())
+    EXPECT_EQ(Platforms.count(Platform), 1U);
+}
+
+TEST(TBDv4, MultipleTargetsSamePlatform) {
+  static const char tbd_multiple_targets_same_platform[] =
+      "--- !tapi-tbd\n"
+      "tbd-version: 4\n"
+      "targets: [ arm64-ios, armv7k-ios ]\n"
+      "install-name: Test.dylib\n"
+      "...\n";
+
+  auto Result = TextAPIReader::get(
+      MemoryBufferRef(tbd_multiple_targets_same_platform, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V4, File->getFileType());
+  EXPECT_EQ(AK_arm64 | AK_armv7k, File->getArchitectures());
+  EXPECT_EQ(File->getPlatforms().size(), 1U);
+  EXPECT_EQ(PlatformKind::iOS, *File->getPlatforms().begin());
+}
+
+TEST(TBDv4, Target_maccatalyst) {
+  static const char tbd_target_maccatalyst[] =
+      "--- !tapi-tbd\n"
+      "tbd-version: 4\n"
+      "targets: [  x86_64-maccatalyst ]\n"
+      "install-name: Test.dylib\n"
+      "...\n";
+
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_target_maccatalyst, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V4, File->getFileType());
+  EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
+  EXPECT_EQ(File->getPlatforms().size(), 1U);
+  EXPECT_EQ(PlatformKind::macCatalyst, *File->getPlatforms().begin());
+}
+
+TEST(TBDv4, Target_x86_ios) {
+  static const char tbd_target_x86_ios[] = "--- !tapi-tbd\n"
+                                           "tbd-version: 4\n"
+                                           "targets: [  x86_64-ios ]\n"
+                                           "install-name: Test.dylib\n"
+                                           "...\n";
+
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_target_x86_ios, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V4, File->getFileType());
+  EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
+  EXPECT_EQ(File->getPlatforms().size(), 1U);
+  EXPECT_EQ(PlatformKind::iOS, *File->getPlatforms().begin());
+}
+
+TEST(TBDv4, Target_arm_bridgeOS) {
+  static const char tbd_platform_bridgeos[] = "--- !tapi-tbd\n"
+                                              "tbd-version: 4\n"
+                                              "targets: [  armv7k-bridgeos ]\n"
+                                              "install-name: Test.dylib\n"
+                                              "...\n";
+
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_platform_bridgeos, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V4, File->getFileType());
+  EXPECT_EQ(File->getPlatforms().size(), 1U);
+  EXPECT_EQ(PlatformKind::bridgeOS, *File->getPlatforms().begin());
+  EXPECT_EQ(ArchitectureSet(AK_armv7k), File->getArchitectures());
+}
+
+TEST(TBDv4, Target_x86_macos) {
+  static const char tbd_x86_macos[] = "--- !tapi-tbd\n"
+                                      "tbd-version: 4\n"
+                                      "targets: [  x86_64-macos ]\n"
+                                      "install-name: Test.dylib\n"
+                                      "...\n";
+
+  auto Result = TextAPIReader::get(MemoryBufferRef(tbd_x86_macos, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V4, File->getFileType());
+  EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
+  EXPECT_EQ(File->getPlatforms().size(), 1U);
+  EXPECT_EQ(PlatformKind::macOS, *File->getPlatforms().begin());
+}
+
+TEST(TBDv4, Target_x86_ios_simulator) {
+  static const char tbd_x86_ios_sim[] = "--- !tapi-tbd\n"
+                                        "tbd-version: 4\n"
+                                        "targets: [  x86_64-ios-simulator  ]\n"
+                                        "install-name: Test.dylib\n"
+                                        "...\n";
+
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_x86_ios_sim, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V4, File->getFileType());
+  EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
+  EXPECT_EQ(File->getPlatforms().size(), 1U);
+  EXPECT_EQ(PlatformKind::iOSSimulator, *File->getPlatforms().begin());
+}
+
+TEST(TBDv4, Target_x86_tvos_simulator) {
+  static const char tbd_x86_tvos_sim[] =
+      "--- !tapi-tbd\n"
+      "tbd-version: 4\n"
+      "targets: [  x86_64-tvos-simulator  ]\n"
+      "install-name: Test.dylib\n"
+      "...\n";
+
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_x86_tvos_sim, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V4, File->getFileType());
+  EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
+  EXPECT_EQ(File->getPlatforms().size(), 1U);
+  EXPECT_EQ(PlatformKind::tvOSSimulator, *File->getPlatforms().begin());
+}
+
+TEST(TBDv4, Target_i386_watchos_simulator) {
+  static const char tbd_i386_watchos_sim[] =
+      "--- !tapi-tbd\n"
+      "tbd-version: 4\n"
+      "targets: [  i386-watchos-simulator  ]\n"
+      "install-name: Test.dylib\n"
+      "...\n";
+
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_i386_watchos_sim, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V4, File->getFileType());
+  EXPECT_EQ(ArchitectureSet(AK_i386), File->getArchitectures());
+  EXPECT_EQ(File->getPlatforms().size(), 1U);
+  EXPECT_EQ(PlatformKind::watchOSSimulator, *File->getPlatforms().begin());
+}
+
+TEST(TBDv4, Swift_1) {
+  static const char tbd_swift_1[] = "--- !tapi-tbd\n"
+                                    "tbd-version: 4\n"
+                                    "targets: [  x86_64-macos ]\n"
+                                    "install-name: Test.dylib\n"
+                                    "swift-abi-version: 1\n"
+                                    "...\n";
+
+  auto Result = TextAPIReader::get(MemoryBufferRef(tbd_swift_1, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V4, File->getFileType());
+  EXPECT_EQ(1U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv4, Swift_2) {
+  static const char tbd_v1_swift_2[] = "--- !tapi-tbd\n"
+                                       "tbd-version: 4\n"
+                                       "targets: [  x86_64-macos ]\n"
+                                       "install-name: Test.dylib\n"
+                                       "swift-abi-version: 2\n"
+                                       "...\n";
+
+  auto Result = TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_2, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V4, File->getFileType());
+  EXPECT_EQ(2U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv4, Swift_5) {
+  static const char tbd_swift_5[] = "--- !tapi-tbd\n"
+                                    "tbd-version: 4\n"
+                                    "targets: [  x86_64-macos ]\n"
+                                    "install-name: Test.dylib\n"
+                                    "swift-abi-version: 5\n"
+                                    "...\n";
+
+  auto Result = TextAPIReader::get(MemoryBufferRef(tbd_swift_5, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V4, File->getFileType());
+  EXPECT_EQ(5U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv4, Swift_99) {
+  static const char tbd_swift_99[] = "--- !tapi-tbd\n"
+                                     "tbd-version: 4\n"
+                                     "targets: [  x86_64-macos ]\n"
+                                     "install-name: Test.dylib\n"
+                                     "swift-abi-version: 99\n"
+                                     "...\n";
+
+  auto Result = TextAPIReader::get(MemoryBufferRef(tbd_swift_99, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V4, File->getFileType());
+  EXPECT_EQ(99U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv4, InvalidArchitecture) {
+  static const char tbd_file_unknown_architecture[] =
+      "--- !tapi-tbd\n"
+      "tbd-version: 4\n"
+      "targets: [ foo-macos ]\n"
+      "install-name: Test.dylib\n"
+      "...\n";
+
+  auto Result = TextAPIReader::get(
+      MemoryBufferRef(tbd_file_unknown_architecture, "Test.tbd"));
+  EXPECT_FALSE(!!Result);
+  auto errorMessage = toString(Result.takeError());
+  ASSERT_TRUE(errorMessage.compare(0, 15, "malformed file\n") == 0);
+}
+
+TEST(TBDv4, InvalidPlatform) {
+  static const char tbd_file_invalid_platform[] = "--- !tapi-tbd\n"
+                                                  "tbd-version: 4\n"
+                                                  "targets: [ x86_64-maos ]\n"
+                                                  "install-name: Test.dylib\n"
+                                                  "...\n";
+
+  auto Result = TextAPIReader::get(
+      MemoryBufferRef(tbd_file_invalid_platform, "Test.tbd"));
+  EXPECT_FALSE(!!Result);
+  auto errorMessage = toString(Result.takeError());
+  ASSERT_TRUE(errorMessage.compare(0, 15, "malformed file\n") == 0);
+}
+
+TEST(TBDv4, MalformedFile1) {
+  static const char malformed_file1[] = "--- !tapi-tbd\n"
+                                        "tbd-version: 4\n"
+                                        "...\n";
+
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(malformed_file1, "Test.tbd"));
+  EXPECT_FALSE(!!Result);
+  auto errorMessage = toString(Result.takeError());
+  ASSERT_EQ("malformed file\nTest.tbd:2:1: error: missing required key "
+            "'targets'\ntbd-version: 4\n^\n",
+            errorMessage);
+}
+
+TEST(TBDv4, MalformedFile2) {
+  static const char malformed_file2[] = "--- !tapi-tbd\n"
+                                        "tbd-version: 4\n"
+                                        "targets: [ x86_64-macos ]\n"
+                                        "install-name: Test.dylib\n"
+                                        "foobar: \"unsupported key\"\n";
+
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(malformed_file2, "Test.tbd"));
+  EXPECT_FALSE(!!Result);
+  auto errorMessage = toString(Result.takeError());
+  ASSERT_EQ(
+      "malformed file\nTest.tbd:5:9: error: unknown key 'foobar'\nfoobar: "
+      "\"unsupported key\"\n        ^~~~~~~~~~~~~~~~~\n",
+      errorMessage);
+}
+
+TEST(TBDv4, MalformedFile3) {
+  static const char tbd_v1_swift_1_1[] = "--- !tapi-tbd\n"
+                                         "tbd-version: 4\n"
+                                         "targets: [  x86_64-macos ]\n"
+                                         "install-name: Test.dylib\n"
+                                         "swift-abi-version: 1.1\n"
+                                         "...\n";
+
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_1_1, "Test.tbd"));
+  EXPECT_FALSE(!!Result);
+  auto errorMessage = toString(Result.takeError());
+  EXPECT_EQ("malformed file\nTest.tbd:5:20: error: invalid Swift ABI "
+            "version.\nswift-abi-version: 1.1\n                   ^~~\n",
+            errorMessage);
+}
+
+} // end namespace TBDv4