[TextAPI] TBD Reader/Writer

[ributzka]

Summary

Add basic infrastructure for reading and writting TBD files (version 1 - 3).

The TextAPI library is not used by anything yet (besides the unit tests). Tool
support will be added in a separate commit.

The TBD format is currently documented in the implementation file (TextStub.cpp).

[mgrang]

llvm/lib/TextAPI/TextStub.cpp

336 ↗

(On Diff #171977)

Please use range based llvm::sort(Section.Symbols), etc instead of std::sort.

See https://llvm.org/docs/CodingStandards.html#beware-of-non-deterministic-sorting-order-of-equal-elements

[dexonsmith]

llvm/lib/TextAPI/TextStub.cpp

337–338 ↗

(On Diff #171977)

Related to @mgrang's comment about using range-based llvm::sort: it looks like there's a bug here where nothing gets sorted, since begin is passed twice.

[compnerd]

llvm/include/llvm/TextAPI/Architecture.def

1 ↗

(On Diff #171977)

Missing copyright header.

llvm/include/llvm/TextAPI/ArchitectureSet.h

172 ↗

(On Diff #171977)

I wonder if we can get away with llvm::BitVector here.

[ributzka]

Replace std::sort with llvm::sort and fix copy-paste-o bugs.

[ributzka]

Add missing license header.

[ributzka]

llvm/include/llvm/TextAPI/ArchitectureSet.h

172 ↗

(On Diff #171977)

A llvm::BitVector would require twice the storage size and dynamic memory allocation/deallocation. I tried to avoid that, since every symbol has an ArchitectureSet associated with it.

[jhenderson]

I haven't looked at all of this yet, by a long way, but here are a few comments on the first few files.

llvm/include/llvm/TextAPI/ArchitectureSet.h

1 ↗

(On Diff #172200)

There's a lot of code in this header that feels like it belongs in a separate .cpp. Doing so would make the class API easier to read, and might reduce the include dependencies.

22 ↗

(On Diff #172200)

I'd be surprised if you need to explicitly include this header, but if you do, it should be cstddef probably.

40 ↗

(On Diff #172200)

This should probably use an ArrayRef.

Do you need to explicit call the ArchitectureSet default constructor in these two?

[jakehehrlich]

General requests

1. Can we namespace MachO specific stuff? I'm fine airing on the side of putting things in the MachO namespace and dedupping later if possible.
2. This is pretty big. Can we break this up at all?
3. I've thus far ignored the parts that are MachO specific and assumed someone else more qualified would handle that. Before giving an LGTM I'd like to see review of that code. Breaking this up would help me to do that if a person more expierenced with MachO isn't present to do that.

llvm/include/llvm/TextAPI/Registry.h

37 ↗

(On Diff #172200)

Where is file_magic defined? I'm going to make a bunch of, very possibly wrong, assumptions here.

Presumably it's computed from MemoryBufferRef as well so requiring the user to pre-compute it is a bit odd. Also not all conceivable formats have magic.

48 ↗

(On Diff #172200)

What would be a case where this would return false?

53 ↗

(On Diff #172200)

Can you explain why this is needed? It seems like this could be split up into a Reader and a Writer.

llvm/lib/TextAPI/TextStub.cpp

591 ↗

(On Diff #172200)

An issue Armando hit was that this doesn't allow comments at the start of TAPI files. It also just seems like a generally error prone way to check for the validity of such files IMO. I think a better way would be to just attempt to parse and handle the failure by attempting to parse the next format. It's unlikely that the parser would actually get very far before failing.

[amontanez]

<bikeshed>
I noticed the library is named TextAPI, is there a specific reason for this? My patch names the library TAPI, but if there's a reason not to I can change that.
</bikeshed>

I'd like to start a conversation on where we'd like the ELF and MachO code paths to diverge. It looks like a thin abstraction of InterfaceFile.h that forks into MachO and ELF specific implementations would be reasonable. TextAPIReaderWriter seems generic enough that it should support an ELF implementation without any modification. In the context of this patch, those places look like reasonable points where implementation specifics might diverge. However, depending on what else would be upstreamed following this patch, I'm not sure if that's the best approach.

An alternative option might be to make this patch provide a single .tbd implementation as independently as possible, and then in separate patches move in the auxiliary (Architecture, Version, Registry, etc.) components later. That would make it significantly easier to provide specific feedback and discussion on whether code is MachO-specific or if some of it could be shared with ELF to reduce code duplication.

The original TAPI is rather large when compared against other llvm libraries, so I'd like to be careful when adding the ELF backend such that it doesn't inflate needlessly. I could adapt the ELF portions to take advantage of existing interfaces after they land, but without more granular review there might be some parts that are specialized and integrated so much that it wouldn't be realistic to do so without completely refactoring existing code.

[jakehehrlich]

In D53945#1289270, @amontanez wrote:

<bikeshed>
I noticed the library is named TextAPI, is there a specific reason for this? My patch names the library TAPI, but if there's a reason not to I can change that.
</bikeshed>

I'd like to start a conversation on where we'd like the ELF and MachO code paths to diverge. It looks like a thin abstraction of InterfaceFile.h that forks into MachO and ELF specific implementations would be reasonable. TextAPIReaderWriter seems generic enough that it should support an ELF implementation without any modification. In the context of this patch, those places look like reasonable points where implementation specifics might diverge. However, depending on what else would be upstreamed following this patch, I'm not sure if that's the best approach.

An alternative option might be to make this patch provide a single .tbd implementation as independently as possible, and then in separate patches move in the auxiliary (Architecture, Version, Registry, etc.) components later. That would make it significantly easier to provide specific feedback and discussion on whether code is MachO-specific or if some of it could be shared with ELF to reduce code duplication.

The original TAPI is rather large when compared against other llvm libraries, so I'd like to be careful when adding the ELF backend such that it doesn't inflate needlessly. I could adapt the ELF portions to take advantage of existing interfaces after they land, but without more granular review there might be some parts that are specialized and integrated so much that it wouldn't be realistic to do so without completely refactoring existing code.

The interface file has *a lot* of MachO specific things in it. It also isn't clear that even Architecture may not even be easily dedupable IMO. The registry interface seems more on the level of split I was expecting. It demands a raw_ostream for the output which isn't ideal IMO because that's not really how you'd ever want to output an ELF file. I focused on that in my review because of that.

[amontanez]

In D53945#1289303, @jakehehrlich wrote:

The interface file has *a lot* of MachO specific things in it. It also isn't clear that even Architecture may not even be easily dedupable IMO. The registry interface seems more on the level of split I was expecting. It demands a raw_ostream for the output which isn't ideal IMO because that's not really how you'd ever want to output an ELF file. I focused on that in my review because of that.

Are you suggesting the Registry has a notion of two (or more) different file definitions (i.e. MachOInterfaceFile and ELFInterfaceFile), or am I misinterpreting?

To clarify, I don't think the API of InterfaceFile could be shared, I was intending to suggest something similar to llvm::object::ObjectFile that would be used in the contexts that InterfaceFile is currently used in. When more specifics are needed (for example, in TextStub.cpp), if the FileType is appropriate then you can downcast to the class with the additional functionality. Does keeping a general interface in that way reduce code duplication enough to be justified? I think it depends on what the tool ends up doing.

[ributzka]

I will update the patch with more changes based on the feedback so far.

llvm/include/llvm/TextAPI/Registry.h

37 ↗

(On Diff #172200)

The additions to file_magic are defined in a separate patch (https://reviews.llvm.org/D37820). This is how libObject works if you want to use the generic interface. If you look at the original patch that is attached to the RFC you can see how it all ties together.

[amontanez]

I've renamed directories in D53051 from TAPI to TextAPI to match this patch.

[ributzka]

• Rebase patch on D53051
• Remove registry and add separate reader and writer classes
• Move everything into the MachO namespace and sub-folder

[jakehehrlich]

Would there be an objection to using llvm::tapi::MachO or llvm::tapi::macho? At least for ELF it doesn't make much sense to put the tapi code in the same namespace as BinaryFormat/ELF so it would be nice to add the extra namespace. I'm not married to the idea however.

[lhames]

Nitpicks aside, the mach-o side of this looks good to me. :)

Is there any other outstanding feedback?

llvm/include/llvm/TextAPI/InterfaceFile.h

165 ↗

(On Diff #171977)

Looks like a partial comment.

And "writter" should be "writer".

181–184 ↗

(On Diff #171977)

Should this be called "addArchitectures" instead, given that it's an additive operation?

llvm/lib/TextAPI/TextStub.cpp

183–191 ↗

(On Diff #171977)

You might be able to use llvm/ADT/BitmaskEnum.h here, rather than defining these operators yourself.

394–395 ↗

(On Diff #171977)

These sorts are no-ops, along the same lines as the ones Duncan pointed out above.

[lhames]

Oops. Those comments were for and old diff. The no-op sorts are gone, but the other three still apply.

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

107

Should this be called "addArchitectures" instead, given that it's an additive operation?

173

Looks like a partial comment?

And "writter" should be "writer".

llvm/lib/TextAPI/MachO/TextStub.cpp

189–197

You might be able to use llvm/ADT/BitmaskEnum.h here, rather than defining these operators yourself.

[ributzka]

• rename setArchitectures to addArchitectures
• fix comments
• use BitmaskEnum in several places to remove custom static_cast code.

[ributzka]

llvm/lib/TextAPI/MachO/TextStub.cpp

189–197

Sweet. I didn't know we had this. This cleaned up the code in several files.

[ributzka]

In D53945#1310580, @jakehehrlich wrote:

Would there be an objection to using llvm::tapi::MachO or llvm::tapi::macho? At least for ELF it doesn't make much sense to put the tapi code in the same namespace as BinaryFormat/ELF so it would be nice to add the extra namespace. I'm not married to the idea however.

I see and use tapi as a top-level namespace for the tapi tool, so it feels weird to have that namespace also as a nested namespace inside llvm.

[lhames]

Looks good to me. :)

[thakis]

Out of interest, why aren't most of the tests for this lit tests? The usual llvm way of testing stuff is to write a small llvm tool using your library (which will be useful outside of a testing context too) and then use that to write lit tests.

[thakis]

In D53945#1343312, @thakis wrote:

Out of interest, why aren't most of the tests for this lit tests? The usual llvm way of testing stuff is to write a small llvm tool using your library (which will be useful outside of a testing context too) and then use that to write lit tests.

Looks like this is now happening (rL350341). Are most of the unit tests going to move to lit tests now?

[steven_wu]

In D53945#1347562, @thakis wrote:

In D53945#1343312, @thakis wrote:

Out of interest, why aren't most of the tests for this lit tests? The usual llvm way of testing stuff is to write a small llvm tool using your library (which will be useful outside of a testing context too) and then use that to write lit tests.

Looks like this is now happening (rL350341). Are most of the unit tests going to move to lit tests now?

This is a different YAML format from r350341 but unittest is running as part of the lit as well, right?
A new tool can be created to read MachO YAML file but I want to understand your real concern here.

[thakis]

In D53945#1348511, @steven_wu wrote:

In D53945#1347562, @thakis wrote:

In D53945#1343312, @thakis wrote:

Out of interest, why aren't most of the tests for this lit tests? The usual llvm way of testing stuff is to write a small llvm tool using your library (which will be useful outside of a testing context too) and then use that to write lit tests.

Looks like this is now happening (rL350341). Are most of the unit tests going to move to lit tests now?

This is a different YAML format from r350341 but unittest is running as part of the lit as well, right?
A new tool can be created to read MachO YAML file but I want to understand your real concern here.

The concerns are:

• being able to iterate on tests without having to wait for a test binary to link
• testing consistent with how the rest of llvm works

[mstorsjo]

llvm/include/llvm/TextAPI/MachO/Architecture.def

17

This seemed to break compilation of LLVM for i386.

When targeting i386, both GCC and Clang define i386 (without underscores), see e.g. https://github.com/llvm-project/clang/blob/master/lib/Basic/Targets/X86.cpp#L897.

The fact that i386 is defined and expands to 1 breaks this ARCHINFO case, as 1 isn't a valid name in enum class Architecture.

llvm/include/llvm/TextAPI/MachO/Architecture.h

+//===- llvm/TextAPI/Architecture.h - Architecture ---------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Defines the architecture enum and helper methods.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TEXTAPI_MACHO_ARCHITECTURE_H
+#define LLVM_TEXTAPI_MACHO_ARCHITECTURE_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+namespace MachO {
+
+/// Defines the architecture slices that are supported by Text-based Stub files.
+enum class Architecture : uint8_t {
+#define ARCHINFO(Arch, Type, SubType) Arch,
+#include "llvm/TextAPI/MachO/Architecture.def"
+#undef ARCHINFO
+  unknown, // this has to go last.
+};
+
+/// Convert a CPU Type and Subtype pair to an architecture slice.
+Architecture getArchitectureFromCpuType(uint32_t CPUType, uint32_t CPUSubType);
+
+/// Convert a name to an architecture slice.
+Architecture getArchitectureFromName(StringRef Name);
+
+/// Convert an architecture slice to a string.
+StringRef getArchitectureName(Architecture Arch);
+
+/// Convert an architecture slice to a CPU Type and Subtype pair.
+std::pair<uint32_t, uint32_t> getCPUTypeFromArchitecture(Architecture Arch);
+
+raw_ostream &operator<<(raw_ostream &OS, Architecture Arch);
+
+} // end namespace MachO.
+} // end namespace llvm.
+
+#endif // LLVM_TEXTAPI_MACHO_ARCHITECTURE_H

llvm/include/llvm/TextAPI/MachO/Architecture.def

+//===- llvm/TextAPI/Architecture.def - Architecture -------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ARCHINFO
+#define ARCHINFO(arch)
+#endif
+
+///
+/// X86 architectures sorted by cpu type and sub type id.
+///
+ARCHINFO(i386, MachO::CPU_TYPE_I386, MachO::CPU_SUBTYPE_I386_ALL)
+ARCHINFO(x86_64, MachO::CPU_TYPE_X86_64, MachO::CPU_SUBTYPE_X86_64_ALL)
+ARCHINFO(x86_64h, MachO::CPU_TYPE_X86_64, MachO::CPU_SUBTYPE_X86_64_H)
+
+
+///
+/// ARM architectures sorted by cpu sub type id.
+///
+ARCHINFO(armv4t, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V4T)
+ARCHINFO(armv6, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V6)
+ARCHINFO(armv5, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V5TEJ)
+ARCHINFO(armv7, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7)
+ARCHINFO(armv7s, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7S)
+ARCHINFO(armv7k, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7K)
+ARCHINFO(armv6m, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V6M)
+ARCHINFO(armv7m, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7M)
+ARCHINFO(armv7em, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7EM)
+
+
+///
+/// ARM64 architectures sorted by cpu sub type id.
+///
+ARCHINFO(arm64, MachO::CPU_TYPE_ARM64, MachO::CPU_SUBTYPE_ARM64_ALL)

llvm/include/llvm/TextAPI/MachO/ArchitectureSet.h

+//===- llvm/TextAPI/ArchitectureSet.h - ArchitectureSet ---------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Defines the architecture set.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TEXTAPI_MACHO_ARCHITECTURE_SET_H
+#define LLVM_TEXTAPI_MACHO_ARCHITECTURE_SET_H
+
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/TextAPI/MachO/Architecture.h"
+#include <cstddef>
+#include <iterator>
+#include <limits>
+#include <vector>
+
+namespace llvm {
+namespace MachO {
+
+class ArchitectureSet {
+private:
+  using ArchSetType = uint32_t;
+
+  const static ArchSetType EndIndexVal =
+      std::numeric_limits<ArchSetType>::max();
+  ArchSetType ArchSet{0};
+
+public:
+  constexpr ArchitectureSet() = default;
+  constexpr ArchitectureSet(ArchSetType Raw) : ArchSet(Raw) {}
+  ArchitectureSet(Architecture Arch) : ArchitectureSet() { set(Arch); }
+  ArchitectureSet(const std::vector<Architecture> &Archs);
+
+  void set(Architecture Arch) {
+    if (Arch == Architecture::unknown)
+      return;
+    ArchSet |= 1U << static_cast<int>(Arch);
+  }
+
+  void clear(Architecture Arch) { ArchSet &= ~(1U << static_cast<int>(Arch)); }
+
+  bool has(Architecture Arch) const {
+    return ArchSet & (1U << static_cast<int>(Arch));
+  }
+
+  bool contains(ArchitectureSet Archs) const {
+    return (ArchSet & Archs.ArchSet) == Archs.ArchSet;
+  }
+
+  size_t count() const;
+
+  bool empty() const { return ArchSet == 0; }
+
+  ArchSetType rawValue() const { return ArchSet; }
+
+  template <typename Ty>
+  class arch_iterator
+      : public std::iterator<std::forward_iterator_tag, Architecture, size_t> {
+  private:
+    ArchSetType Index;
+    Ty *ArchSet;
+
+    void findNextSetBit();
+
+  public:
+    arch_iterator(Ty *ArchSet, ArchSetType Index = 0)
+        : Index(Index), ArchSet(ArchSet) {
+      if (Index != EndIndexVal && !(*ArchSet & (1UL << Index)))
+        findNextSetBit();
+    }
+
+    Architecture operator*() const { return static_cast<Architecture>(Index); }
+
+    arch_iterator &operator++() {
+      findNextSetBit();
+      return *this;
+    }
+
+    arch_iterator operator++(int) {
+      auto tmp = *this;
+      findNextSetBit();
+      return tmp;
+    }
+
+    bool operator==(const arch_iterator &o) const {
+      return std::tie(Index, ArchSet) == std::tie(o.Index, o.ArchSet);
+    }
+
+    bool operator!=(const arch_iterator &o) const { return !(*this == o); }
+  };
+
+  ArchitectureSet operator&(const ArchitectureSet &o) {
+    return {ArchSet & o.ArchSet};
+  }
+
+  ArchitectureSet operator|(const ArchitectureSet &o) {
+    return {ArchSet | o.ArchSet};
+  }
+
+  ArchitectureSet &operator|=(const ArchitectureSet &o) {
+    ArchSet |= o.ArchSet;
+    return *this;
+  }
+
+  ArchitectureSet &operator|=(const Architecture &Arch) {
+    set(Arch);
+    return *this;
+  }
+
+  bool operator==(const ArchitectureSet &o) const {
+    return ArchSet == o.ArchSet;
+  }
+
+  bool operator!=(const ArchitectureSet &o) const {
+    return ArchSet != o.ArchSet;
+  }
+
+  bool operator<(const ArchitectureSet &o) const { return ArchSet < o.ArchSet; }
+
+  using iterator = arch_iterator<ArchSetType>;
+  using const_iterator = arch_iterator<const ArchSetType>;
+
+  iterator begin() { return {&ArchSet}; }
+  iterator end() { return {&ArchSet, EndIndexVal}; }
+
+  const_iterator begin() const { return {&ArchSet}; }
+  const_iterator end() const { return {&ArchSet, EndIndexVal}; }
+
+  operator std::string() const;
+  operator std::vector<Architecture>() const;
+  void print(raw_ostream &OS) const;
+};
+
+inline ArchitectureSet operator|(const Architecture &lhs,
+                                 const Architecture &rhs) {
+  return ArchitectureSet(lhs) | ArchitectureSet(rhs);
+}
+
+raw_ostream &operator<<(raw_ostream &OS, ArchitectureSet Set);
+
+} // end namespace MachO.
+} // end namespace llvm.
+
+#endif // LLVM_TEXTAPI_MACHO_ARCHITECTURE_SET_H

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

+//===- llvm/TextAPI/IntefaceFile.h - TAPI Interface File --------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief A generic and abstract interface representation for linkable objects.
+///        This could be an MachO executable, bundle, dylib, or text-based stub
+///        file.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TEXTAPI_MACHO_INTERFACE_FILE_H
+#define LLVM_TEXTAPI_MACHO_INTERFACE_FILE_H
+
+#include "llvm/ADT/BitmaskEnum.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator.h"
+#include "llvm/BinaryFormat/MachO.h"
+#include "llvm/BinaryFormat/Magic.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/Error.h"
+#include "llvm/TextAPI/MachO/Architecture.h"
+#include "llvm/TextAPI/MachO/ArchitectureSet.h"
+#include "llvm/TextAPI/MachO/PackedVersion.h"
+#include "llvm/TextAPI/MachO/Symbol.h"
+
+namespace llvm {
+namespace MachO {
+
+/// Defines the list of MachO platforms.
+enum class Platform : unsigned {
+  unknown,
+  macOS = MachO::PLATFORM_MACOS,
+  iOS = MachO::PLATFORM_IOS,
+  tvOS = MachO::PLATFORM_TVOS,
+  watchOS = MachO::PLATFORM_WATCHOS,
+  bridgeOS = MachO::PLATFORM_BRIDGEOS,
+};
+
+/// Defines a list of Objective-C constraints.
+enum class ObjCConstraint : unsigned {
+  /// No constraint.
+  None = 0,
+
+  /// Retain/Release.
+  Retain_Release = 1,
+
+  /// Retain/Release for Simulator.
+  Retain_Release_For_Simulator = 2,
+
+  /// Retain/Release or Garbage Collection.
+  Retain_Release_Or_GC = 3,
+
+  /// Garbage Collection.
+  GC = 4,
+};
+
+// clang-format off
+
+/// Defines the file type this file represents.
+enum FileType : unsigned {
+  /// Invalid file type.
+  Invalid = 0U,
+
+  /// Text-based stub file (.tbd) version 1.0
+  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,
+
+  All     = ~0U,
+
+  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/All),
+};
+
+// clang-format on
+
+/// Reference to an interface file.
+class InterfaceFileRef {
+public:
+  InterfaceFileRef() = default;
+
+  InterfaceFileRef(StringRef InstallName) : InstallName(InstallName) {}
+
+  InterfaceFileRef(StringRef InstallName, ArchitectureSet Archs)
+      : InstallName(InstallName), Architectures(Archs) {}
+
+  StringRef getInstallName() const { return InstallName; };
+  void addArchitectures(ArchitectureSet Archs) { Architectures |= Archs; }
+  ArchitectureSet getArchitectures() const { return Architectures; }
+  bool hasArchitecture(Architecture Arch) const {
+    return Architectures.has(Arch);
+  }
+
+  bool operator==(const InterfaceFileRef &O) const {
+    return std::tie(InstallName, Architectures) ==
+           std::tie(O.InstallName, O.Architectures);
+  }
+
+  bool operator<(const InterfaceFileRef &O) const {
+    return std::tie(InstallName, Architectures) <
+           std::tie(O.InstallName, O.Architectures);
+  }
+
+private:
+  std::string InstallName;
+  ArchitectureSet Architectures;
+};
+
+} // end namespace MachO.
+
+struct SymbolsMapKey {
+  MachO::SymbolKind Kind;
+  StringRef Name;
+
+  SymbolsMapKey(MachO::SymbolKind Kind, StringRef Name)
+      : Kind(Kind), Name(Name) {}
+};
+template <> struct DenseMapInfo<SymbolsMapKey> {
+  static inline SymbolsMapKey getEmptyKey() {
+    return SymbolsMapKey(MachO::SymbolKind::GlobalSymbol, StringRef{});
+  }
+
+  static inline SymbolsMapKey getTombstoneKey() {
+    return SymbolsMapKey(MachO::SymbolKind::ObjectiveCInstanceVariable,
+                         StringRef{});
+  }
+
+  static unsigned getHashValue(const SymbolsMapKey &Key) {
+    return hash_combine(hash_value(Key.Kind), hash_value(Key.Name));
+  }
+
+  static bool isEqual(const SymbolsMapKey &LHS, const SymbolsMapKey &RHS) {
+    return std::tie(LHS.Kind, LHS.Name) == std::tie(RHS.Kind, RHS.Name);
+  }
+};
+
+namespace MachO {
+
+/// Defines the interface file.
+class InterfaceFile {
+public:
+  /// Set the path from which this file was generated (if applicable).
+  ///
+  /// \param Path_ The path to the source file.
+  void setPath(StringRef Path_) { Path = Path_; }
+
+  /// Get the path from which this file was generated (if applicable).
+  ///
+  /// \return The path to the source file or empty.
+  StringRef getPath() const { return Path; }
+
+  /// Set the file type.
+  ///
+  /// This is used by the YAML writer to identify the specification it should
+  /// use for writing the file.
+  ///
+  /// \param Type The file type.
+  void setFileType(FileType Type) { FileType = Type; }
+
+  /// Get the file type.
+  ///
+  /// \return The file type.
+  FileType getFileType() const { return FileType; }
+
+  /// Set the platform.
+  void setPlatform(Platform Platform_) { Platform = Platform_; }
+
+  /// Get the platform.
+  Platform getPlatform() const { return Platform; }
+
+  /// Specify the set of supported architectures by this file.
+  void setArchitectures(ArchitectureSet Architectures_) {
+    Architectures = Architectures_;
+  }
+
+  /// Add the set of supported architectures by this file.
+  void addArchitectures(ArchitectureSet Architectures_) {
+    Architectures |= Architectures_;
+  }
+
+  /// Add supported architecture by this file..
+  void addArch(Architecture Arch) { Architectures.set(Arch); }
+
+  /// Get the set of supported architectures.
+  ArchitectureSet getArchitectures() const { return Architectures; }
+
+  /// Set the install name of the library.
+  void setInstallName(StringRef InstallName_) { InstallName = InstallName_; }
+
+  /// Get the install name of the library.
+  StringRef getInstallName() const { return InstallName; }
+
+  /// Set the current version of the library.
+  void setCurrentVersion(PackedVersion Version) { CurrentVersion = Version; }
+
+  /// Get the current version of the library.
+  PackedVersion getCurrentVersion() const { return CurrentVersion; }
+
+  /// Set the compatibility version of the library.
+  void setCompatibilityVersion(PackedVersion Version) {
+    CompatibilityVersion = Version;
+  }
+
+  /// Get the compatibility version of the library.
+  PackedVersion getCompatibilityVersion() const { return CompatibilityVersion; }
+
+  /// Set the Swift ABI version of the library.
+  void setSwiftABIVersion(uint8_t Version) { SwiftABIVersion = Version; }
+
+  /// Get the Swift ABI version of the library.
+  uint8_t getSwiftABIVersion() const { return SwiftABIVersion; }
+
+  /// Specify if the library uses two-level namespace (or flat namespace).
+  void setTwoLevelNamespace(bool V = true) { IsTwoLevelNamespace = V; }
+
+  /// Check if the library uses two-level namespace.
+  bool isTwoLevelNamespace() const { return IsTwoLevelNamespace; }
+
+  /// Specify if the library is application extension safe (or not).
+  void setApplicationExtensionSafe(bool V = true) { IsAppExtensionSafe = V; }
+
+  /// Check if the library is application extension safe.
+  bool isApplicationExtensionSafe() const { return IsAppExtensionSafe; }
+
+  /// Set the Objective-C constraint.
+  void setObjCConstraint(ObjCConstraint Constraint) {
+    ObjcConstraint = Constraint;
+  }
+
+  /// Get the Objective-C constraint.
+  ObjCConstraint getObjCConstraint() const { return ObjcConstraint; }
+
+  /// Specify if this file was generated during InstallAPI (or not).
+  void setInstallAPI(bool V = true) { IsInstallAPI = V; }
+
+  /// Check if this file was generated during InstallAPI.
+  bool isInstallAPI() const { return IsInstallAPI; }
+
+  /// Set the parent umbrella framework.
+  void setParentUmbrella(StringRef Parent) { ParentUmbrella = Parent; }
+
+  /// Get the parent umbrella framework.
+  StringRef getParentUmbrella() const { return ParentUmbrella; }
+
+  /// Add an allowable client.
+  ///
+  /// Mach-O Dynamic libraries have the concept of allowable clients that are
+  /// checked during static link time. The name of the application or library
+  /// that is being generated needs to match one of the allowable clients or the
+  /// linker refuses to link this library.
+  ///
+  /// \param Name The name of the client that is allowed to link this library.
+  /// \param Architectures The set of architecture for which this applies.
+  void addAllowableClient(StringRef Name, ArchitectureSet Architectures);
+
+  /// Get the list of allowable clients.
+  ///
+  /// \return Returns a list of allowable clients.
+  const std::vector<InterfaceFileRef> &allowableClients() const {
+    return AllowableClients;
+  }
+
+  /// Add a re-exported library.
+  ///
+  /// \param Name The name of the library to re-export.
+  /// \param Architectures The set of architecture for which this applies.
+  void addReexportedLibrary(StringRef InstallName,
+                            ArchitectureSet Architectures);
+
+  /// Get the list of re-exported libraries.
+  ///
+  /// \return Returns a list of re-exported libraries.
+  const std::vector<InterfaceFileRef> &reexportedLibraries() const {
+    return ReexportedLibraries;
+  }
+
+  /// Add an architecture/UUID pair.
+  ///
+  /// \param Arch The architecture for which this applies.
+  /// \param UUID The UUID of the library for the specified architecture.
+  void addUUID(Architecture Arch, StringRef UUID);
+
+  /// Add an architecture/UUID pair.
+  ///
+  /// \param Arch The architecture for which this applies.
+  /// \param UUID The UUID of the library for the specified architecture.
+  void addUUID(Architecture Arch, uint8_t UUID[16]);
+
+  /// Get the list of architecture/UUID pairs.
+  ///
+  /// \return Returns a list of architecture/UUID pairs.
+  const std::vector<std::pair<Architecture, std::string>> &uuids() const {
+    return UUIDs;
+  }
+
+  /// Add a symbol to the symbols list or extend an existing one.
+  void addSymbol(SymbolKind Kind, StringRef Name, ArchitectureSet Architectures,
+                 SymbolFlags Flags = SymbolFlags::None);
+
+  using SymbolMapType = DenseMap<SymbolsMapKey, Symbol *>;
+  struct const_symbol_iterator
+      : public iterator_adaptor_base<
+            const_symbol_iterator, SymbolMapType::const_iterator,
+            std::forward_iterator_tag, const Symbol *, ptrdiff_t,
+            const Symbol *, const Symbol *> {
+    const_symbol_iterator() = default;
+
+    template <typename U>
+    const_symbol_iterator(U &&u)
+        : iterator_adaptor_base(std::forward<U &&>(u)) {}
+
+    reference operator*() const { return I->second; }
+    pointer operator->() const { return I->second; }
+  };
+  using const_symbol_range = iterator_range<const_symbol_iterator>;
+
+  // Custom iterator to return only exported symbols.
+  struct const_export_iterator
+      : public iterator_adaptor_base<
+            const_export_iterator, const_symbol_iterator,
+            std::forward_iterator_tag, const Symbol *> {
+    const_symbol_iterator _end;
+
+    void skipToNextSymbol() {
+      while (I != _end && I->isUndefined())
+        ++I;
+    }
+
+    const_export_iterator() = default;
+    template <typename U>
+    const_export_iterator(U &&it, U &&end)
+        : iterator_adaptor_base(std::forward<U &&>(it)),
+          _end(std::forward<U &&>(end)) {
+      skipToNextSymbol();
+    }
+
+    const_export_iterator &operator++() {
+      ++I;
+      skipToNextSymbol();
+      return *this;
+    }
+
+    const_export_iterator operator++(int) {
+      const_export_iterator tmp(*this);
+      ++(*this);
+      return tmp;
+    }
+  };
+  using const_export_range = llvm::iterator_range<const_export_iterator>;
+
+  // Custom iterator to return only undefined symbols.
+  struct const_undefined_iterator
+      : public iterator_adaptor_base<
+            const_undefined_iterator, const_symbol_iterator,
+            std::forward_iterator_tag, const Symbol *> {
+    const_symbol_iterator _end;
+
+    void skipToNextSymbol() {
+      while (I != _end && !I->isUndefined())
+        ++I;
+    }
+
+    const_undefined_iterator() = default;
+    template <typename U>
+    const_undefined_iterator(U &&it, U &&end)
+        : iterator_adaptor_base(std::forward<U &&>(it)),
+          _end(std::forward<U &&>(end)) {
+      skipToNextSymbol();
+    }
+
+    const_undefined_iterator &operator++() {
+      ++I;
+      skipToNextSymbol();
+      return *this;
+    }
+
+    const_undefined_iterator operator++(int) {
+      const_undefined_iterator tmp(*this);
+      ++(*this);
+      return tmp;
+    }
+  };
+  using const_undefined_range = llvm::iterator_range<const_undefined_iterator>;
+
+  const_symbol_range symbols() const {
+    return {Symbols.begin(), Symbols.end()};
+  }
+  const_export_range exports() const {
+    return {{Symbols.begin(), Symbols.end()}, {Symbols.end(), Symbols.end()}};
+  }
+  const_undefined_range undefineds() const {
+    return {{Symbols.begin(), Symbols.end()}, {Symbols.end(), Symbols.end()}};
+  }
+
+private:
+  llvm::BumpPtrAllocator Allocator;
+  StringRef copyString(StringRef String) {
+    if (String.empty())
+      return {};
+
+    void *Ptr = Allocator.Allocate(String.size(), 1);
+    memcpy(Ptr, String.data(), String.size());
+    return StringRef(reinterpret_cast<const char *>(Ptr), String.size());
+  }
+
+  std::string Path;
+  FileType FileType;
+  Platform Platform = Platform::unknown;
+  ArchitectureSet Architectures;
+  std::string InstallName;
+  PackedVersion CurrentVersion;
+  PackedVersion CompatibilityVersion;
+  uint8_t SwiftABIVersion{0};
+  bool IsTwoLevelNamespace{false};
+  bool IsAppExtensionSafe{false};
+  bool IsInstallAPI{false};
+  ObjCConstraint ObjcConstraint = ObjCConstraint::None;
+  std::string ParentUmbrella;
+  std::vector<InterfaceFileRef> AllowableClients;
+  std::vector<InterfaceFileRef> ReexportedLibraries;
+  std::vector<std::pair<Architecture, std::string>> UUIDs;
+  SymbolMapType Symbols;
+};
+
+} // end namespace MachO.
+} // end namespace llvm.
+
+#endif // LLVM_TEXTAPI_MACHO_INTERFACE_FILE_H

llvm/include/llvm/TextAPI/MachO/PackedVersion.h

+//===- llvm/TextAPI/PackedVersion.h - PackedVersion -------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Defines the Mach-O packed version format.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TEXTAPI_MACHO_PACKED_VERSION_H
+#define LLVM_TEXTAPI_MACHO_PACKED_VERSION_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+namespace MachO {
+
+class PackedVersion {
+  uint32_t Version{0};
+
+public:
+  constexpr PackedVersion() = default;
+  explicit constexpr PackedVersion(uint32_t RawVersion) : Version(RawVersion) {}
+  PackedVersion(unsigned Major, unsigned Minor, unsigned Subminor)
+      : Version((Major << 16) | ((Minor & 0xff) << 8) | (Subminor & 0xff)) {}
+
+  bool empty() const { return Version == 0; }
+
+  /// Retrieve the major version number.
+  unsigned getMajor() const { return Version >> 16; }
+
+  /// Retrieve the minor version number, if provided.
+  unsigned getMinor() const { return (Version >> 8) & 0xff; }
+
+  /// Retrieve the subminor version number, if provided.
+  unsigned getSubminor() const { return Version & 0xff; }
+
+  bool parse32(StringRef Str);
+  std::pair<bool, bool> parse64(StringRef Str);
+
+  bool operator<(const PackedVersion &O) const { return Version < O.Version; }
+
+  bool operator==(const PackedVersion &O) const { return Version == O.Version; }
+
+  bool operator!=(const PackedVersion &O) const { return Version != O.Version; }
+
+  uint32_t rawValue() const { return Version; }
+
+  void print(raw_ostream &OS) const;
+};
+
+inline raw_ostream &operator<<(raw_ostream &OS, const PackedVersion &Version) {
+  Version.print(OS);
+  return OS;
+}
+
+} // end namespace MachO.
+} // end namespace llvm.
+
+#endif // LLVM_TEXTAPI_MACHO_PACKED_VERSION_H

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

+//===- llvm/TextAPI/Symbol.h - TAPI Symbol ----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Symbol
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TEXTAPI_MACHO_SYMBOL_H
+#define LLVM_TEXTAPI_MACHO_SYMBOL_H
+
+#include "llvm/ADT/BitmaskEnum.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/TextAPI/MachO/ArchitectureSet.h"
+
+namespace llvm {
+namespace MachO {
+
+// clang-format off
+
+/// Symbol flags.
+enum class SymbolFlags : uint8_t {
+  /// No flags
+  None             = 0,
+
+  /// Thread-local value symbol
+  ThreadLocalValue = 1U << 0,
+
+  /// Weak defined symbol
+  WeakDefined      = 1U << 1,
+
+  /// Weak referenced symbol
+  WeakReferenced   = 1U << 2,
+
+  /// Undefined
+  Undefined        = 1U << 3,
+
+  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Undefined),
+};
+
+// clang-format on
+
+enum class SymbolKind : uint8_t {
+  GlobalSymbol,
+  ObjectiveCClass,
+  ObjectiveCClassEHType,
+  ObjectiveCInstanceVariable,
+};
+
+class Symbol {
+public:
+  constexpr Symbol(SymbolKind Kind, StringRef Name,
+                   ArchitectureSet Architectures, SymbolFlags Flags)
+      : Name(Name), Architectures(Architectures), Kind(Kind), Flags(Flags) {}
+
+  SymbolKind getKind() const { return Kind; }
+  StringRef getName() const { return Name; }
+  ArchitectureSet getArchitectures() const { return Architectures; }
+  void addArchitectures(ArchitectureSet Archs) { Architectures |= Archs; }
+  SymbolFlags getFlags() const { return Flags; }
+
+  bool isWeakDefined() const {
+    return (Flags & SymbolFlags::WeakDefined) == SymbolFlags::WeakDefined;
+  }
+
+  bool isWeakReferenced() const {
+    return (Flags & SymbolFlags::WeakReferenced) == SymbolFlags::WeakReferenced;
+  }
+
+  bool isThreadLocalValue() const {
+    return (Flags & SymbolFlags::ThreadLocalValue) ==
+           SymbolFlags::ThreadLocalValue;
+  }
+
+  bool isUndefined() const {
+    return (Flags & SymbolFlags::Undefined) == SymbolFlags::Undefined;
+  }
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  void dump(raw_ostream &OS) const;
+  void dump() const { dump(llvm::errs()); }
+#endif
+
+private:
+  StringRef Name;
+  ArchitectureSet Architectures;
+  SymbolKind Kind;
+  SymbolFlags Flags;
+};
+
+} // end namespace MachO.
+} // end namespace llvm.
+
+#endif // LLVM_TEXTAPI_MACHO_SYMBOL_H

llvm/include/llvm/TextAPI/MachO/TextAPIReader.h

+//===--- TextAPIReader.h - Text API Reader ----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TEXTAPI_MACHO_READER_H
+#define LLVM_TEXTAPI_MACHO_READER_H
+
+#include "llvm/Support/Error.h"
+#include "llvm/Support/MemoryBuffer.h"
+
+namespace llvm {
+namespace MachO {
+
+class InterfaceFile;
+
+class TextAPIReader {
+public:
+  static Expected<std::unique_ptr<InterfaceFile>>
+  get(std::unique_ptr<MemoryBuffer> InputBuffer);
+
+  static Expected<std::unique_ptr<InterfaceFile>>
+  getUnmanaged(llvm::MemoryBuffer *InputBuffer);
+
+  TextAPIReader() = delete;
+};
+
+} // end namespace MachO.
+} // end namespace llvm.
+
+#endif // LLVM_TEXTAPI_MACHO_READER_H

llvm/include/llvm/TextAPI/MachO/TextAPIWriter.h

+//===--- TextAPIWriter.h - Text API Writer ----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TEXTAPI_MACHO_WRITER_H
+#define LLVM_TEXTAPI_MACHO_WRITER_H
+
+#include "llvm/Support/MemoryBuffer.h"
+
+namespace llvm {
+namespace MachO {
+
+class InterfaceFile;
+
+class TextAPIWriter {
+public:
+  TextAPIWriter() = delete;
+
+  static Error writeToStream(raw_ostream &os, const InterfaceFile &);
+};
+
+} // end namespace MachO.
+} // end namespace llvm.
+
+#endif // LLVM_TEXTAPI_MACHO_WRITER_H

llvm/lib/CMakeLists.txt

 # `Demangle', `Support' and `TableGen' libraries are added on the top-level
 # CMakeLists.txt
 
 add_subdirectory(IR)
 add_subdirectory(FuzzMutate)
 add_subdirectory(IRReader)
 add_subdirectory(CodeGen)
 add_subdirectory(BinaryFormat)
 add_subdirectory(Bitcode)
 add_subdirectory(Transforms)
 add_subdirectory(Linker)
 add_subdirectory(Analysis)
 add_subdirectory(LTO)
 add_subdirectory(MC)
+add_subdirectory(TextAPI)
 add_subdirectory(Object)
 add_subdirectory(ObjectYAML)
 add_subdirectory(Option)
 add_subdirectory(OptRemarks)
 add_subdirectory(DebugInfo)
 add_subdirectory(ExecutionEngine)
 add_subdirectory(Target)
 add_subdirectory(AsmParser)
 add_subdirectory(LineEditor)
 add_subdirectory(ProfileData)
 add_subdirectory(Passes)
-add_subdirectory(TextAPI)
 add_subdirectory(ToolDrivers)
 add_subdirectory(XRay)
 add_subdirectory(Testing)
 add_subdirectory(WindowsManifest)

llvm/lib/LLVMBuild.txt

  BinaryFormat
  ObjectYAML
  Option
  OptRemarks
  Passes
  ProfileData
  Support
  TableGen
- TextAPI
  Target
  Testing
+ TextAPI
  ToolDrivers
  Transforms
  WindowsManifest
  XRay
 
 [component_0]
 type = Group
 name = Libraries
 parent = $ROOT

llvm/lib/TextAPI/CMakeLists.txt

 add_llvm_library(LLVMTextAPI
   ELF/ELFStub.cpp
   ELF/TBEHandler.cpp
+  MachO/Architecture.cpp
+  MachO/ArchitectureSet.cpp
+  MachO/InterfaceFile.cpp
+  MachO/PackedVersion.cpp
+  MachO/Symbol.cpp
+  MachO/TextStub.cpp
+  MachO/TextStubCommon.cpp
 
   ADDITIONAL_HEADER_DIRS
   "${LLVM_MAIN_INCLUDE_DIR}/llvm/TextAPI"
 )

llvm/lib/TextAPI/LLVMBuild.txt

-;===- ./lib/Support/LLVMBuild.txt ------------------------------*- Conf -*--===;
+;===- ./lib/TextAPI/LLVMBuild.txt ------------------------------*- Conf -*--===;
 ;
 ;                     The LLVM Compiler Infrastructure
 ;
 ; This file is distributed under the University of Illinois Open Source
 ; License. See LICENSE.TXT for details.
 ;
 ;===------------------------------------------------------------------------===;
 ;
 ; This is an LLVMBuild description file for the components in this subdirectory.
 ;
 ; For more information on the LLVMBuild system, please see:
 ;
 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Library
 name = TextAPI
 parent = Libraries
-required_libraries = Object Support BinaryFormat
+required_libraries = Support BinaryFormat

llvm/lib/TextAPI/MachO/Architecture.cpp

+//===- llvm/TextAPI/Architecture.cpp - Architecture -------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Implements the architecture helper functions.
+///
+//===----------------------------------------------------------------------===//
+
+#include "llvm/TextAPI/MachO/Architecture.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/BinaryFormat/MachO.h"
+
+namespace llvm {
+namespace MachO {
+
+Architecture getArchitectureFromCpuType(uint32_t CPUType, uint32_t CPUSubType) {
+#define ARCHINFO(Arch, Type, Subtype)                                          \
+  if (CPUType == (Type) &&                                                     \
+      (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) == (Subtype))                    \
+    return Architecture::Arch;
+#include "llvm/TextAPI/MachO/Architecture.def"
+#undef ARCHINFO
+
+  return Architecture::unknown;
+}
+
+Architecture getArchitectureFromName(StringRef Name) {
+  return StringSwitch<Architecture>(Name)
+#define ARCHINFO(Arch, Type, Subtype) .Case(#Arch, Architecture::Arch)
+#include "llvm/TextAPI/MachO/Architecture.def"
+#undef ARCHINFO
+      .Default(Architecture::unknown);
+}
+
+StringRef getArchitectureName(Architecture Arch) {
+  switch (Arch) {
+#define ARCHINFO(Arch, Type, Subtype)                                          \
+  case Architecture::Arch:                                                     \
+    return #Arch;
+#include "llvm/TextAPI/MachO/Architecture.def"
+#undef ARCHINFO
+  case Architecture::unknown:
+    return "unknown";
+  }
+}
+
+std::pair<uint32_t, uint32_t> getCPUTypeFromArchitecture(Architecture Arch) {
+  switch (Arch) {
+#define ARCHINFO(Arch, Type, Subtype)                                          \
+  case Architecture::Arch:                                                     \
+    return std::make_pair(Type, Subtype);
+#include "llvm/TextAPI/MachO/Architecture.def"
+#undef ARCHINFO
+  case Architecture::unknown:
+    return std::make_pair(0, 0);
+  }
+}
+
+raw_ostream &operator<<(raw_ostream &OS, Architecture Arch) {
+  OS << getArchitectureName(Arch);
+  return OS;
+}
+
+} // end namespace MachO.
+} // end namespace llvm.

llvm/lib/TextAPI/MachO/ArchitectureSet.cpp

+//===- llvm/TextAPI/ArchitectureSet.cpp - Architecture Set ------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Implements the architecture set.
+///
+//===----------------------------------------------------------------------===//
+
+#include "llvm/TextAPI/MachO/ArchitectureSet.h"
+
+namespace llvm {
+namespace MachO {
+
+ArchitectureSet::ArchitectureSet(const std::vector<Architecture> &Archs)
+    : ArchitectureSet() {
+  for (auto Arch : Archs) {
+    if (Arch == Architecture::unknown)
+      continue;
+    set(Arch);
+  }
+}
+
+size_t ArchitectureSet::count() const {
+  // popcnt
+  size_t Cnt = 0;
+  for (unsigned i = 0; i < sizeof(ArchSetType) * 8; ++i)
+    if (ArchSet & (1U << i))
+      ++Cnt;
+  return Cnt;
+}
+
+template <typename Ty>
+void ArchitectureSet::arch_iterator<Ty>::findNextSetBit() {
+  if (Index == EndIndexVal)
+    return;
+
+  do {
+    if (*ArchSet & (1UL << ++Index))
+      return;
+  } while (Index < sizeof(Ty) * 8);
+
+  Index = EndIndexVal;
+}
+
+ArchitectureSet::operator std::string() const {
+  if (empty())
+    return "[(empty)]";
+
+  std::string result;
+  auto size = count();
+  for (auto arch : *this) {
+    result.append(getArchitectureName(arch));
+    size -= 1;
+    if (size)
+      result.append(" ");
+  }
+  return result;
+}
+
+ArchitectureSet::operator std::vector<Architecture>() const {
+  std::vector<Architecture> archs;
+  for (auto arch : *this) {
+    if (arch == Architecture::unknown)
+      continue;
+    archs.emplace_back(arch);
+  }
+  return archs;
+}
+
+void ArchitectureSet::print(raw_ostream &os) const { os << std::string(*this); }
+
+raw_ostream &operator<<(raw_ostream &os, ArchitectureSet set) {
+  set.print(os);
+  return os;
+}
+
+} // end namespace MachO.
+} // end namespace llvm.

llvm/lib/TextAPI/MachO/InterfaceFile.cpp

+//===- lib/TextAPI/InterfaceFile.cpp - Interface File -----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Implements the Interface File.
+///
+//===----------------------------------------------------------------------===//
+
+#include "llvm/TextAPI/MachO/InterfaceFile.h"
+#include <iomanip>
+#include <sstream>
+
+using namespace llvm::MachO;
+
+namespace llvm {
+namespace MachO {
+namespace detail {
+template <typename C>
+typename C::iterator addEntry(C &Container, StringRef InstallName) {
+  auto I =
+      std::lower_bound(std::begin(Container), std::end(Container), InstallName,
+                       [](const InterfaceFileRef &LHS, const StringRef &RHS) {
+                         return LHS.getInstallName() < RHS;
+                       });
+  if ((I != std::end(Container)) && !(InstallName < I->getInstallName()))
+    return I;
+
+  return Container.emplace(I, InstallName);
+}
+} // end namespace detail.
+
+void InterfaceFile::addAllowableClient(StringRef Name,
+                                       ArchitectureSet Architectures) {
+  auto Client = detail::addEntry(AllowableClients, Name);
+  Client->addArchitectures(Architectures);
+}
+
+void InterfaceFile::addReexportedLibrary(StringRef InstallName,
+                                         ArchitectureSet Architectures) {
+  auto Lib = detail::addEntry(ReexportedLibraries, InstallName);
+  Lib->addArchitectures(Architectures);
+}
+
+void InterfaceFile::addUUID(Architecture Arch, StringRef UUID) {
+  auto I = std::lower_bound(UUIDs.begin(), UUIDs.end(), Arch,
+                            [](const std::pair<Architecture, std::string> &LHS,
+                               Architecture RHS) { return LHS.first < RHS; });
+
+  if ((I != UUIDs.end()) && !(Arch < I->first)) {
+    I->second = UUID;
+    return;
+  }
+
+  UUIDs.emplace(I, Arch, UUID);
+  return;
+}
+
+void InterfaceFile::addUUID(Architecture Arch, uint8_t UUID[16]) {
+  std::stringstream Stream;
+  for (unsigned i = 0; i < 16; ++i) {
+    if (i == 4 || i == 6 || i == 8 || i == 10)
+      Stream << '-';
+    Stream << std::setfill('0') << std::setw(2) << std::uppercase << std::hex
+           << static_cast<int>(UUID[i]);
+  }
+  addUUID(Arch, Stream.str());
+}
+
+void InterfaceFile::addSymbol(SymbolKind Kind, StringRef Name,
+                              ArchitectureSet Archs, 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};
+  else
+    result.first->second->addArchitectures(Archs);
+}
+
+} // end namespace MachO.
+} // end namespace llvm.

llvm/lib/TextAPI/MachO/PackedVersion.cpp

+//===- llvm/TextAPI/PackedVersion.cpp - PackedVersion -----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Implements the Mach-O packed version.
+///
+//===----------------------------------------------------------------------===//
+
+#include "llvm/TextAPI/MachO/PackedVersion.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+namespace MachO {
+
+bool PackedVersion::parse32(StringRef Str) {
+  Version = 0;
+
+  if (Str.empty())
+    return false;
+
+  SmallVector<StringRef, 3> Parts;
+  SplitString(Str, Parts, ".");
+
+  if (Parts.size() > 3)
+    return false;
+
+  unsigned long long Num;
+  if (getAsUnsignedInteger(Parts[0], 10, Num))
+    return false;
+
+  if (Num > UINT16_MAX)
+    return false;
+
+  Version = Num << 16;
+
+  for (unsigned i = 1, ShiftNum = 8; i < Parts.size(); ++i, ShiftNum -= 8) {
+    if (getAsUnsignedInteger(Parts[i], 10, Num))
+      return false;
+
+    if (Num > UINT8_MAX)
+      return false;
+
+    Version |= (Num << ShiftNum);
+  }
+
+  return true;
+}
+
+std::pair<bool, bool> PackedVersion::parse64(StringRef Str) {
+  bool Truncated = false;
+  Version = 0;
+
+  if (Str.empty())
+    return std::make_pair(false, Truncated);
+
+  SmallVector<StringRef, 5> Parts;
+  SplitString(Str, Parts, ".");
+
+  if (Parts.size() > 5)
+    return std::make_pair(false, Truncated);
+
+  unsigned long long Num;
+  if (getAsUnsignedInteger(Parts[0], 10, Num))
+    return std::make_pair(false, Truncated);
+
+  if (Num > 0xFFFFFFULL)
+    return std::make_pair(false, Truncated);
+
+  if (Num > 0xFFFFULL) {
+    Num = 0xFFFFULL;
+    Truncated = true;
+  }
+  Version = Num << 16;
+
+  for (unsigned i = 1, ShiftNum = 8; i < Parts.size() && i < 3;
+       ++i, ShiftNum -= 8) {
+    if (getAsUnsignedInteger(Parts[i], 10, Num))
+      return std::make_pair(false, Truncated);
+
+    if (Num > 0x3FFULL)
+      return std::make_pair(false, Truncated);
+
+    if (Num > 0xFFULL) {
+      Num = 0xFFULL;
+      Truncated = true;
+    }
+    Version |= (Num << ShiftNum);
+  }
+
+  if (Parts.size() > 3)
+    Truncated = true;
+
+  return std::make_pair(true, Truncated);
+}
+
+void PackedVersion::print(raw_ostream &OS) const {
+  OS << format("%d", getMajor());
+  if (getMinor() || getSubminor())
+    OS << format(".%d", getMinor());
+  if (getSubminor())
+    OS << format(".%d", getSubminor());
+}
+
+} // end namespace MachO.
+} // end namespace llvm.

llvm/lib/TextAPI/MachO/Symbol.cpp

+//===- lib/TextAPI/Symbol.cpp - Symbol --------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Implements the Symbol
+///
+//===----------------------------------------------------------------------===//
+
+#include "llvm/TextAPI/MachO/Symbol.h"
+#include <string>
+
+namespace llvm {
+namespace MachO {
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+LLVM_DUMP_METHOD void Symbol::dump(raw_ostream &OS) const {
+  std::string Result;
+  if (isUndefined())
+    Result += "(undef) ";
+  if (isWeakDefined())
+    Result += "(weak-def) ";
+  if (isWeakReferenced())
+    Result += "(weak-ref) ";
+  if (isThreadLocalValue())
+    Result += "(tlv) ";
+  switch (Kind) {
+  case SymbolKind::GlobalSymbol:
+    Result + Name.str();
+    break;
+  case SymbolKind::ObjectiveCClass:
+    Result + "(ObjC Class) " + Name.str();
+    break;
+  case SymbolKind::ObjectiveCClassEHType:
+    Result + "(ObjC Class EH) " + Name.str();
+    break;
+  case SymbolKind::ObjectiveCInstanceVariable:
+    Result + "(ObjC IVar) " + Name.str();
+    break;
+  }
+  OS << Result;
+}
+#endif
+
+} // end namespace MachO.
+} // end namespace llvm.

llvm/lib/TextAPI/MachO/TextAPIContext.h

+//===- llvm/TextAPI/YAMLContext.h - YAML Context ----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Defines the YAML Context for the TextAPI Reader/Writer
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TEXTAPI_MACHO_CONTEXT_H
+#define LLVM_TEXTAPI_MACHO_CONTEXT_H
+
+#include "llvm/Support/MemoryBuffer.h"
+#include <string>
+
+namespace llvm {
+namespace MachO {
+
+enum FileType : unsigned;
+
+struct TextAPIContext {
+  std::string ErrorMessage;
+  std::string Path;
+  FileType FileType;
+};
+
+} // end namespace MachO.
+} // end namespace llvm.
+
+#endif // LLVM_TEXTAPI_MACHO_CONTEXT_H

llvm/lib/TextAPI/MachO/TextStub.cpp

+//===- llvm/TextAPI/TextStub.cpp - Text Stub --------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Implements the text stub file reader/writer.
+///
+//===----------------------------------------------------------------------===//
+
+#include "TextAPIContext.h"
+#include "TextStubCommon.h"
+#include "llvm/ADT/BitmaskEnum.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/YAMLTraits.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/TextAPI/MachO/Architecture.h"
+#include "llvm/TextAPI/MachO/ArchitectureSet.h"
+#include "llvm/TextAPI/MachO/InterfaceFile.h"
+#include "llvm/TextAPI/MachO/PackedVersion.h"
+#include "llvm/TextAPI/MachO/TextAPIReader.h"
+#include "llvm/TextAPI/MachO/TextAPIWriter.h"
+#include <algorithm>
+#include <set>
+
+// clang-format off
+/*
+
+ YAML Format specification.
+
+ The TBD v1 format only support two level address libraries and is per
+ definition application extension safe.
+
+---                              # the tag !tapi-tbd-v1 is optional and
+                                 # shouldn't be emitted to support older linker.
+archs: [ armv7, armv7s, arm64 ]  # the list of architecture slices that are
+                                 # supported by this file.
+platform: ios                    # Specifies the platform (macosx, ios, etc)
+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-version: 0                 # Optional: defaults to 0
+objc-constraint: none            # Optional: defaults to none
+exports:                         # List of export sections
+...
+
+Each export section is defined as following:
+
+ - archs: [ arm64 ]                   # the list of architecture slices
+   allowed-clients: [ client ]        # Optional: List of clients
+   re-exports: [ ]                    # Optional: List of re-exports
+   symbols: [ _sym ]                  # Optional: List of symbols
+   objc-classes: []                   # Optional: List of Objective-C classes
+   objc-ivars: []                     # Optional: List of Objective C Instance
+                                      #           Variables
+   weak-def-symbols: []               # Optional: List of weak defined symbols
+   thread-local-symbols: []           # Optional: List of thread local symbols
+*/
+
+/*
+
+ YAML Format specification.
+
+--- !tapi-tbd-v2
+archs: [ armv7, armv7s, arm64 ]  # the list of architecture slices that are
+                                 # supported by this file.
+uuids: [ armv7:... ]             # Optional: List of architecture and UUID pairs.
+platform: ios                    # Specifies the platform (macosx, ios, etc)
+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-version: 0                 # Optional: defaults to 0
+objc-constraint: retain_release  # Optional: defaults to retain_release
+parent-umbrella:                 # Optional:
+exports:                         # List of export sections
+...
+undefineds:                      # List of undefineds sections
+...
+
+Each export section is defined as following:
+
+- archs: [ arm64 ]                   # the list of architecture slices
+  allowed-clients: [ client ]        # Optional: List of clients
+  re-exports: [ ]                    # Optional: List of re-exports
+  symbols: [ _sym ]                  # Optional: List of symbols
+  objc-classes: []                   # Optional: List of Objective-C classes
+  objc-ivars: []                     # Optional: List of Objective C Instance
+                                     #           Variables
+  weak-def-symbols: []               # Optional: List of weak defined symbols
+  thread-local-symbols: []           # Optional: List of thread local symbols
+
+Each undefineds section is defined as following:
+- archs: [ arm64 ]     # the list of architecture slices
+  symbols: [ _sym ]    # Optional: List of symbols
+  objc-classes: []     # Optional: List of Objective-C classes
+  objc-ivars: []       # Optional: List of Objective C Instance Variables
+  weak-ref-symbols: [] # Optional: List of weak defined symbols
+*/
+
+/*
+
+ YAML Format specification.
+
+--- !tapi-tbd-v3
+archs: [ armv7, armv7s, arm64 ]  # the list of architecture slices that are
+                                 # supported by this file.
+uuids: [ armv7:... ]             # Optional: List of architecture and UUID pairs.
+platform: ios                    # Specifies the platform (macosx, ios, etc)
+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
+objc-constraint: retain_release  # Optional: defaults to retain_release
+parent-umbrella:                 # Optional:
+exports:                         # List of export sections
+...
+undefineds:                      # List of undefineds sections
+...
+
+Each export section is defined as following:
+
+- archs: [ arm64 ]                   # the list of architecture slices
+  allowed-clients: [ client ]        # Optional: List of clients
+  re-exports: [ ]                    # Optional: List of re-exports
+  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-def-symbols: []               # Optional: List of weak defined symbols
+  thread-local-symbols: []           # Optional: List of thread local symbols
+
+Each undefineds section is defined as following:
+- 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
+*/
+// clang-format on
+
+using namespace llvm;
+using namespace llvm::yaml;
+using namespace llvm::MachO;
+
+namespace {
+struct ExportSection {
+  std::vector<Architecture> Architectures;
+  std::vector<FlowStringRef> AllowableClients;
+  std::vector<FlowStringRef> ReexportedLibraries;
+  std::vector<FlowStringRef> Symbols;
+  std::vector<FlowStringRef> Classes;
+  std::vector<FlowStringRef> ClassEHs;
+  std::vector<FlowStringRef> IVars;
+  std::vector<FlowStringRef> WeakDefSymbols;
+  std::vector<FlowStringRef> TLVSymbols;
+};
+
+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;
+};
+
+// clang-format off
+enum Flags : 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)
+
+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->FileType != FileType::Invalid) &&
+           "File type is not set in YAML context");
+
+    IO.mapRequired("archs", Section.Architectures);
+    if (Ctx->FileType == FileType::TBD_V1)
+      IO.mapOptional("allowed-clients", Section.AllowableClients);
+    else
+      IO.mapOptional("allowable-clients", Section.AllowableClients);
+    IO.mapOptional("re-exports", Section.ReexportedLibraries);
+    IO.mapOptional("symbols", Section.Symbols);
+    IO.mapOptional("objc-classes", Section.Classes);
+    if (Ctx->FileType == FileType::TBD_V3)
+      IO.mapOptional("objc-eh-types", Section.ClassEHs);
+    IO.mapOptional("objc-ivars", Section.IVars);
+    IO.mapOptional("weak-def-symbols", Section.WeakDefSymbols);
+    IO.mapOptional("thread-local-symbols", Section.TLVSymbols);
+  }
+};
+
+template <> struct MappingTraits<UndefinedSection> {
+  static void mapping(IO &IO, UndefinedSection &Section) {
+    const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
+    assert((!Ctx || Ctx && Ctx->FileType != FileType::Invalid) &&
+           "File type is not set in YAML context");
+
+    IO.mapRequired("archs", Section.Architectures);
+    IO.mapOptional("symbols", Section.Symbols);
+    IO.mapOptional("objc-classes", Section.Classes);
+    if (Ctx->FileType == 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 ScalarBitSetTraits<Flags> {
+  static void bitset(IO &IO, Flags &Flags) {
+    IO.bitSetCase(Flags, "flat_namespace", Flags::FlatNamespace);
+    IO.bitSetCase(Flags, "not_app_extension_safe",
+                  Flags::NotApplicationExtensionSafe);
+    IO.bitSetCase(Flags, "installapi", Flags::InstallAPI);
+  }
+};
+
+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();
+      InstallName = File->getInstallName();
+      CurrentVersion = PackedVersion(File->getCurrentVersion());
+      CompatibilityVersion = PackedVersion(File->getCompatibilityVersion());
+      SwiftVersion = File->getSwiftABIVersion();
+      ObjCConstraint = File->getObjCConstraint();
+
+      Flags = Flags::None;
+      if (!File->isApplicationExtensionSafe())
+        Flags |= Flags::NotApplicationExtensionSafe;
+
+      if (!File->isTwoLevelNamespace())
+        Flags |= Flags::FlatNamespace;
+
+      if (File->isInstallAPI())
+        Flags |= Flags::InstallAPI;
+
+      ParentUmbrella = File->getParentUmbrella();
+
+      std::set<ArchitectureSet> ArchSet;
+      for (const auto &Library : File->allowableClients())
+        ArchSet.insert(Library.getArchitectures());
+
+      for (const auto &Library : File->reexportedLibraries())
+        ArchSet.insert(Library.getArchitectures());
+
+      std::map<const Symbol *, ArchitectureSet> SymbolToArchSet;
+      for (const auto *Symbol : File->exports()) {
+        auto Architectures = Symbol->getArchitectures();
+        SymbolToArchSet[Symbol] = Architectures;
+        ArchSet.insert(Architectures);
+      }
+
+      for (auto Architectures : ArchSet) {
+        ExportSection Section;
+        Section.Architectures = Architectures;
+
+        for (const auto &Library : File->allowableClients())
+          if (Library.getArchitectures() == Architectures)
+            Section.AllowableClients.emplace_back(Library.getInstallName());
+
+        for (const auto &Library : File->reexportedLibraries())
+          if (Library.getArchitectures() == Architectures)
+            Section.ReexportedLibraries.emplace_back(Library.getInstallName());
+
+        for (const auto &SymArch : SymbolToArchSet) {
+          if (SymArch.second != Architectures)
+            continue;
+
+          const auto *Symbol = SymArch.first;
+          switch (Symbol->getKind()) {
+          case SymbolKind::GlobalSymbol:
+            if (Symbol->isWeakDefined())
+              Section.WeakDefSymbols.emplace_back(Symbol->getName());
+            else if (Symbol->isThreadLocalValue())
+              Section.TLVSymbols.emplace_back(Symbol->getName());
+            else
+              Section.Symbols.emplace_back(Symbol->getName());
+            break;
+          case SymbolKind::ObjectiveCClass:
+            if (File->getFileType() != FileType::TBD_V3)
+              Section.Classes.emplace_back(
+                  copyString("_" + Symbol->getName().str()));
+            else
+              Section.Classes.emplace_back(Symbol->getName());
+            break;
+          case SymbolKind::ObjectiveCClassEHType:
+            if (File->getFileType() != FileType::TBD_V3)
+              Section.Symbols.emplace_back(
+                  copyString("_OBJC_EHTYPE_$_" + Symbol->getName().str()));
+            else
+              Section.ClassEHs.emplace_back(Symbol->getName());
+            break;
+          case SymbolKind::ObjectiveCInstanceVariable:
+            if (File->getFileType() != FileType::TBD_V3)
+              Section.IVars.emplace_back(
+                  copyString("_" + Symbol->getName().str()));
+            else
+              Section.IVars.emplace_back(Symbol->getName());
+            break;
+          }
+        }
+        llvm::sort(Section.Symbols.begin(), Section.Symbols.end());
+        llvm::sort(Section.Classes.begin(), Section.Classes.end());
+        llvm::sort(Section.ClassEHs.begin(), Section.ClassEHs.end());
+        llvm::sort(Section.IVars.begin(), Section.IVars.end());
+        llvm::sort(Section.WeakDefSymbols.begin(),
+                   Section.WeakDefSymbols.end());
+        llvm::sort(Section.TLVSymbols.begin(), Section.TLVSymbols.end());
+        Exports.emplace_back(std::move(Section));
+      }
+
+      ArchSet.clear();
+      SymbolToArchSet.clear();
+
+      for (const auto *Symbol : File->undefineds()) {
+        auto Architectures = Symbol->getArchitectures();
+        SymbolToArchSet[Symbol] = Architectures;
+        ArchSet.insert(Architectures);
+      }
+
+      for (auto Architectures : ArchSet) {
+        UndefinedSection Section;
+        Section.Architectures = Architectures;
+
+        for (const auto &SymArch : SymbolToArchSet) {
+          if (SymArch.second != Architectures)
+            continue;
+
+          const auto *Symbol = SymArch.first;
+          switch (Symbol->getKind()) {
+          case SymbolKind::GlobalSymbol:
+            if (Symbol->isWeakReferenced())
+              Section.WeakRefSymbols.emplace_back(Symbol->getName());
+            else
+              Section.Symbols.emplace_back(Symbol->getName());
+            break;
+          case SymbolKind::ObjectiveCClass:
+            if (File->getFileType() != FileType::TBD_V3)
+              Section.Classes.emplace_back(
+                  copyString("_" + Symbol->getName().str()));
+            else
+              Section.Classes.emplace_back(Symbol->getName());
+            break;
+          case SymbolKind::ObjectiveCClassEHType:
+            if (File->getFileType() != FileType::TBD_V3)
+              Section.Symbols.emplace_back(
+                  copyString("_OBJC_EHTYPE_$_" + Symbol->getName().str()));
+            else
+              Section.ClassEHs.emplace_back(Symbol->getName());
+            break;
+          case SymbolKind::ObjectiveCInstanceVariable:
+            if (File->getFileType() != FileType::TBD_V3)
+              Section.IVars.emplace_back(
+                  copyString("_" + Symbol->getName().str()));
+            else
+              Section.IVars.emplace_back(Symbol->getName());
+            break;
+          }
+        }
+        llvm::sort(Section.Symbols.begin(), Section.Symbols.end());
+        llvm::sort(Section.Classes.begin(), Section.Classes.end());
+        llvm::sort(Section.ClassEHs.begin(), Section.ClassEHs.end());
+        llvm::sort(Section.IVars.begin(), Section.IVars.end());
+        llvm::sort(Section.WeakRefSymbols.begin(),
+                   Section.WeakRefSymbols.end());
+        Undefineds.emplace_back(std::move(Section));
+      }
+    }
+
+    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->FileType);
+      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(SwiftVersion);
+      File->setObjCConstraint(ObjCConstraint);
+      File->setParentUmbrella(ParentUmbrella);
+
+      if (Ctx->FileType == FileType::TBD_V1) {
+        File->setTwoLevelNamespace();
+        File->setApplicationExtensionSafe();
+      } else {
+        File->setTwoLevelNamespace(!(Flags & Flags::FlatNamespace));
+        File->setApplicationExtensionSafe(
+            !(Flags & Flags::NotApplicationExtensionSafe));
+        File->setInstallAPI(Flags & Flags::InstallAPI);
+      }
+
+      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);
+
+        for (const auto &Symbol : Section.Symbols) {
+          if (Ctx->FileType != FileType::TBD_V3 &&
+              Symbol.value.startswith("_OBJC_EHTYPE_$_"))
+            File->addSymbol(SymbolKind::ObjectiveCClassEHType,
+                            Symbol.value.drop_front(15), Section.Architectures);
+          else
+            File->addSymbol(SymbolKind::GlobalSymbol, Symbol,
+                            Section.Architectures);
+        }
+        for (auto &Symbol : Section.Classes) {
+          auto Name = Symbol.value;
+          if (Ctx->FileType != FileType::TBD_V3)
+            Name = Name.drop_front();
+          File->addSymbol(SymbolKind::ObjectiveCClass, Name,
+                          Section.Architectures);
+        }
+        for (auto &Symbol : Section.ClassEHs)
+          File->addSymbol(SymbolKind::ObjectiveCClassEHType, Symbol,
+                          Section.Architectures);
+        for (auto &Symbol : Section.IVars) {
+          auto Name = Symbol.value;
+          if (Ctx->FileType != FileType::TBD_V3)
+            Name = Name.drop_front();
+          File->addSymbol(SymbolKind::ObjectiveCInstanceVariable, Name,
+                          Section.Architectures);
+        }
+        for (auto &Symbol : Section.WeakDefSymbols)
+          File->addSymbol(SymbolKind::GlobalSymbol, Symbol,
+                          Section.Architectures, SymbolFlags::WeakDefined);
+        for (auto &Symbol : Section.TLVSymbols)
+          File->addSymbol(SymbolKind::GlobalSymbol, Symbol,
+                          Section.Architectures, SymbolFlags::ThreadLocalValue);
+      }
+
+      for (const auto &Section : Undefineds) {
+        for (auto &Symbol : Section.Symbols) {
+          if (Ctx->FileType != FileType::TBD_V3 &&
+              Symbol.value.startswith("_OBJC_EHTYPE_$_"))
+            File->addSymbol(SymbolKind::ObjectiveCClassEHType,
+                            Symbol.value.drop_front(15), Section.Architectures,
+                            SymbolFlags::Undefined);
+          else
+            File->addSymbol(SymbolKind::GlobalSymbol, Symbol,
+                            Section.Architectures, SymbolFlags::Undefined);
+        }
+        for (auto &Symbol : Section.Classes) {
+          auto Name = Symbol.value;
+          if (Ctx->FileType != FileType::TBD_V3)
+            Name = Name.drop_front();
+          File->addSymbol(SymbolKind::ObjectiveCClass, Name,
+                          Section.Architectures, SymbolFlags::Undefined);
+        }
+        for (auto &Symbol : Section.ClassEHs)
+          File->addSymbol(SymbolKind::ObjectiveCClassEHType, Symbol,
+                          Section.Architectures, SymbolFlags::Undefined);
+        for (auto &Symbol : Section.IVars) {
+          auto Name = Symbol.value;
+          if (Ctx->FileType != FileType::TBD_V3)
+            Name = Name.drop_front();
+          File->addSymbol(SymbolKind::ObjectiveCInstanceVariable, Name,
+                          Section.Architectures, SymbolFlags::Undefined);
+        }
+        for (auto &Symbol : Section.WeakRefSymbols)
+          File->addSymbol(SymbolKind::GlobalSymbol, Symbol,
+                          Section.Architectures,
+                          SymbolFlags::Undefined | SymbolFlags::WeakReferenced);
+      }
+
+      return File;
+    }
+
+    llvm::BumpPtrAllocator Allocator;
+    StringRef copyString(StringRef String) {
+      if (String.empty())
+        return {};
+
+      void *Ptr = Allocator.Allocate(String.size(), 1);
+      memcpy(Ptr, String.data(), String.size());
+      return StringRef(reinterpret_cast<const char *>(Ptr), String.size());
+    }
+
+    std::vector<Architecture> Architectures;
+    std::vector<UUID> UUIDs;
+    Platform Platform{Platform::unknown};
+    StringRef InstallName;
+    PackedVersion CurrentVersion;
+    PackedVersion CompatibilityVersion;
+    SwiftVersion SwiftVersion;
+    ObjCConstraint ObjCConstraint;
+    Flags Flags{Flags::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->FileType != 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->FileType = FileType::TBD_V2;
+      else if (IO.mapTag("!tapi-tbd-v3", false))
+        Ctx->FileType = FileType::TBD_V2;
+      else if (IO.mapTag("!tapi-tbd-v1", false) ||
+               IO.mapTag("tag:yaml.org,2002:map", false))
+        Ctx->FileType = FileType::TBD_V1;
+      else {
+        IO.setError("unsupported file type");
+        return;
+      }
+    }
+
+    // Set file tyoe when writing.
+    if (IO.outputting()) {
+      switch (Ctx->FileType) {
+      default:
+        llvm_unreachable("unexpected file type");
+      case FileType::TBD_V1:
+        // Don't write the tag into the .tbd file for TBD v1.
+        break;
+      case FileType::TBD_V2:
+        IO.mapTag("!tapi-tbd-v2", true);
+        break;
+      case FileType::TBD_V3:
+        IO.mapTag("!tapi-tbd-v3", true);
+        break;
+      }
+    }
+
+    IO.mapRequired("archs", Keys->Architectures);
+    if (Ctx->FileType != FileType::TBD_V1)
+      IO.mapOptional("uuids", Keys->UUIDs);
+    IO.mapRequired("platform", Keys->Platform);
+    if (Ctx->FileType != FileType::TBD_V1)
+      IO.mapOptional("flags", Keys->Flags, Flags::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->FileType != FileType::TBD_V3)
+      IO.mapOptional("swift-version", Keys->SwiftVersion, SwiftVersion(0));
+    else
+      IO.mapOptional("swift-abi-version", Keys->SwiftVersion, SwiftVersion(0));
+    IO.mapOptional("objc-constraint", Keys->ObjCConstraint,
+                   (Ctx->FileType == FileType::TBD_V1)
+                       ? ObjCConstraint::None
+                       : ObjCConstraint::Retain_Release);
+    if (Ctx->FileType != FileType::TBD_V1)
+      IO.mapOptional("parent-umbrella", Keys->ParentUmbrella, StringRef());
+    IO.mapOptional("exports", Keys->Exports);
+    if (Ctx->FileType != FileType::TBD_V1)
+      IO.mapOptional("undefineds", Keys->Undefineds);
+  }
+};
+
+template <>
+struct DocumentListTraits<std::vector<const MachO::InterfaceFile *>> {
+  static size_t size(IO &IO, std::vector<const MachO::InterfaceFile *> &Seq) {
+    return Seq.size();
+  }
+  static const InterfaceFile *&
+  element(IO &IO, std::vector<const InterfaceFile *> &Seq, size_t Index) {
+    if (Index >= Seq.size())
+      Seq.resize(Index + 1);
+    return Seq[Index];
+  }
+};
+
+} // end namespace yaml.
+
+namespace MachO {
+static void DiagHandler(const SMDiagnostic &Diag, void *Context) {
+  auto *File = static_cast<TextAPIContext *>(Context);
+  SmallString<1024> Message;
+  raw_svector_ostream S(Message);
+
+  SMDiagnostic NewDiag(*Diag.getSourceMgr(), Diag.getLoc(), File->Path,
+                       Diag.getLineNo(), Diag.getColumnNo(), Diag.getKind(),
+                       Diag.getMessage(), Diag.getLineContents(),
+                       Diag.getRanges(), Diag.getFixIts());
+
+  NewDiag.print(nullptr, S);
+  File->ErrorMessage = ("malformed file\n" + Message).str();
+}
+
+Expected<std::unique_ptr<InterfaceFile>>
+TextAPIReader::get(std::unique_ptr<MemoryBuffer> InputBuffer) {
+  TextAPIContext 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;
+
+  if (YAMLIn.error())
+    return make_error<StringError>(Ctx.ErrorMessage, YAMLIn.error());
+
+  auto *File = const_cast<InterfaceFile *>(Files.front());
+  return std::unique_ptr<InterfaceFile>(File);
+}
+
+Error TextAPIWriter::writeToStream(raw_ostream &OS, const InterfaceFile &File) {
+  TextAPIContext Ctx;
+  Ctx.Path = File.getPath();
+  Ctx.FileType = File.getFileType();
+  llvm::yaml::Output YAMLOut(OS, &Ctx, /*WrapColumn=*/80);
+
+  std::vector<const InterfaceFile *> Files;
+  Files.emplace_back(&File);
+
+  // Stream out yaml.
+  YAMLOut << Files;
+
+  return Error::success();
+}
+
+} // end namespace MachO.
+} // end namespace llvm.

llvm/lib/TextAPI/MachO/TextStubCommon.h

+//===- llvm/TextAPI/TextStubCommon.h - Text Stub Common ---------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Defines common Text Stub YAML mappings.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TEXTAPI_TEXT_STUB_COMMON_H
+#define LLVM_TEXTAPI_TEXT_STUB_COMMON_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/YAMLTraits.h"
+#include "llvm/TextAPI/MachO/Architecture.h"
+#include "llvm/TextAPI/MachO/ArchitectureSet.h"
+#include "llvm/TextAPI/MachO/InterfaceFile.h"
+#include "llvm/TextAPI/MachO/PackedVersion.h"
+
+using UUID = std::pair<llvm::MachO::Architecture, std::string>;
+
+LLVM_YAML_STRONG_TYPEDEF(llvm::StringRef, FlowStringRef)
+LLVM_YAML_STRONG_TYPEDEF(uint8_t, SwiftVersion)
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(UUID)
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FlowStringRef)
+
+namespace llvm {
+namespace yaml {
+
+template <> struct ScalarTraits<FlowStringRef> {
+  static void output(const FlowStringRef &, void *, raw_ostream &);
+  static StringRef input(StringRef, void *, FlowStringRef &);
+  static QuotingType mustQuote(StringRef);
+};
+
+template <> struct ScalarEnumerationTraits<MachO::ObjCConstraint> {
+  static void enumeration(IO &, MachO::ObjCConstraint &);
+};
+
+template <> struct ScalarTraits<MachO::Platform> {
+  static void output(const MachO::Platform &, void *, raw_ostream &);
+  static StringRef input(StringRef, void *, MachO::Platform &);
+  static QuotingType mustQuote(StringRef);
+};
+
+template <> struct ScalarBitSetTraits<MachO::ArchitectureSet> {
+  static void bitset(IO &, MachO::ArchitectureSet &);
+};
+
+template <> struct ScalarTraits<MachO::Architecture> {
+  static void output(const MachO::Architecture &, void *, raw_ostream &);
+  static StringRef input(StringRef, void *, MachO::Architecture &);
+  static QuotingType mustQuote(StringRef);
+};
+
+template <> struct ScalarTraits<MachO::PackedVersion> {
+  static void output(const MachO::PackedVersion &, void *, raw_ostream &);
+  static StringRef input(StringRef, void *, MachO::PackedVersion &);
+  static QuotingType mustQuote(StringRef);
+};
+
+template <> struct ScalarTraits<SwiftVersion> {
+  static void output(const SwiftVersion &, void *, raw_ostream &);
+  static StringRef input(StringRef, void *, SwiftVersion &);
+  static QuotingType mustQuote(StringRef);
+};
+
+template <> struct ScalarTraits<UUID> {
+  static void output(const UUID &, void *, raw_ostream &);
+  static StringRef input(StringRef, void *, UUID &);
+  static QuotingType mustQuote(StringRef);
+};
+
+} // end namespace yaml.
+} // end namespace llvm.
+
+#endif // LLVM_TEXTAPI_TEXT_STUB_COMMON_H

llvm/lib/TextAPI/MachO/TextStubCommon.cpp

+//===- lib/TextAPI/TextStubCommon.cpp - Text Stub Common --------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Implememts common Text Stub YAML mappings.
+///
+//===----------------------------------------------------------------------===//
+
+#include "TextStubCommon.h"
+#include "TextAPIContext.h"
+
+using namespace llvm::MachO;
+
+namespace llvm {
+namespace yaml {
+
+void ScalarTraits<FlowStringRef>::output(const FlowStringRef &Value, void *Ctx,
+                                         raw_ostream &OS) {
+  ScalarTraits<StringRef>::output(Value, Ctx, OS);
+}
+StringRef ScalarTraits<FlowStringRef>::input(StringRef Value, void *Ctx,
+                                             FlowStringRef &Out) {
+  return ScalarTraits<StringRef>::input(Value, Ctx, Out.value);
+}
+QuotingType ScalarTraits<FlowStringRef>::mustQuote(StringRef Name) {
+  return ScalarTraits<StringRef>::mustQuote(Name);
+}
+
+void ScalarEnumerationTraits<ObjCConstraint>::enumeration(
+    IO &IO, ObjCConstraint &Constraint) {
+  IO.enumCase(Constraint, "none", ObjCConstraint::None);
+  IO.enumCase(Constraint, "retain_release", ObjCConstraint::Retain_Release);
+  IO.enumCase(Constraint, "retain_release_for_simulator",
+              ObjCConstraint::Retain_Release_For_Simulator);
+  IO.enumCase(Constraint, "retain_release_or_gc",
+              ObjCConstraint::Retain_Release_Or_GC);
+  IO.enumCase(Constraint, "gc", ObjCConstraint::GC);
+}
+
+void ScalarTraits<Platform>::output(const Platform &Value, void *,
+                                    raw_ostream &OS) {
+  switch (Value) {
+  default:
+    llvm_unreachable("unexpected platform");
+    break;
+  case Platform::macOS:
+    OS << "macosx";
+    break;
+  case Platform::iOS:
+    OS << "ios";
+    break;
+  case Platform::watchOS:
+    OS << "watchos";
+    break;
+  case Platform::tvOS:
+    OS << "tvos";
+    break;
+  case Platform::bridgeOS:
+    OS << "bridgeos";
+    break;
+  }
+}
+StringRef ScalarTraits<Platform>::input(StringRef Scalar, void *,
+                                        Platform &Value) {
+  Value = StringSwitch<Platform>(Scalar)
+              .Case("macosx", Platform::macOS)
+              .Case("ios", Platform::iOS)
+              .Case("watchos", Platform::watchOS)
+              .Case("tvos", Platform::tvOS)
+              .Case("bridgeos", Platform::bridgeOS)
+              .Default(Platform::unknown);
+
+  if (Value == Platform::unknown)
+    return "unknown platform";
+  return {};
+}
+QuotingType ScalarTraits<Platform>::mustQuote(StringRef) {
+  return QuotingType::None;
+}
+
+void ScalarBitSetTraits<ArchitectureSet>::bitset(IO &IO,
+                                                 ArchitectureSet &Archs) {
+#define ARCHINFO(arch, type, subtype)                                          \
+  IO.bitSetCase(Archs, #arch, 1U << static_cast<int>(Architecture::arch));
+#include "llvm/TextAPI/MachO/Architecture.def"
+#undef ARCHINFO
+}
+
+void ScalarTraits<Architecture>::output(const Architecture &Value, void *,
+                                        raw_ostream &OS) {
+  OS << Value;
+}
+StringRef ScalarTraits<Architecture>::input(StringRef Scalar, void *,
+                                            Architecture &Value) {
+  Value = getArchitectureFromName(Scalar);
+  return {};
+}
+QuotingType ScalarTraits<Architecture>::mustQuote(StringRef) {
+  return QuotingType::None;
+}
+
+void ScalarTraits<PackedVersion>::output(const PackedVersion &Value, void *,
+                                         raw_ostream &OS) {
+  OS << Value;
+}
+StringRef ScalarTraits<PackedVersion>::input(StringRef Scalar, void *,
+                                             PackedVersion &Value) {
+  if (!Value.parse32(Scalar))
+    return "invalid packed version string.";
+  return {};
+}
+QuotingType ScalarTraits<PackedVersion>::mustQuote(StringRef) {
+  return QuotingType::None;
+}
+
+void ScalarTraits<SwiftVersion>::output(const SwiftVersion &Value, void *,
+                                        raw_ostream &OS) {
+  switch (Value) {
+  case 1:
+    OS << "1.0";
+    break;
+  case 2:
+    OS << "1.1";
+    break;
+  case 3:
+    OS << "2.0";
+    break;
+  case 4:
+    OS << "3.0";
+    break;
+  default:
+    OS << (unsigned)Value;
+    break;
+  }
+}
+StringRef ScalarTraits<SwiftVersion>::input(StringRef Scalar, void *,
+                                            SwiftVersion &Value) {
+  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();
+}
+QuotingType ScalarTraits<SwiftVersion>::mustQuote(StringRef) {
+  return QuotingType::None;
+}
+
+void ScalarTraits<UUID>::output(const UUID &Value, void *, raw_ostream &OS) {
+  OS << Value.first << ": " << Value.second;
+}
+StringRef ScalarTraits<UUID>::input(StringRef Scalar, void *, UUID &Value) {
+  auto Split = Scalar.split(':');
+  auto Arch = Split.first.trim();
+  auto UUID = Split.second.trim();
+  if (UUID.empty())
+    return "invalid uuid string pair";
+  Value.first = getArchitectureFromName(Arch);
+  Value.second = UUID;
+  return {};
+}
+QuotingType ScalarTraits<UUID>::mustQuote(StringRef) {
+  return QuotingType::Single;
+}
+
+} // end namespace yaml.
+} // end namespace llvm.

llvm/unittests/CMakeLists.txt

 add_subdirectory(MI)
 add_subdirectory(Object)
 add_subdirectory(ObjectYAML)
 add_subdirectory(Option)
 add_subdirectory(OptRemarks)
 add_subdirectory(Passes)
 add_subdirectory(ProfileData)
 add_subdirectory(Support)
-add_subdirectory(TextAPI)
 add_subdirectory(Target)
+add_subdirectory(TextAPI)
 add_subdirectory(Transforms)
 add_subdirectory(XRay)
 add_subdirectory(tools)

llvm/unittests/TextAPI/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   TextAPI
 )
 
-add_llvm_unittest(TapiTests
+add_llvm_unittest(TextAPITests
   ELFYAMLTest.cpp
+  TextStubV1Tests.cpp
+  TextStubV2Tests.cpp
 )

llvm/unittests/TextAPI/TextStubV1Tests.cpp

+//===-- TextStubV1Tests.cpp - TBD V1 File Test ----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#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;
+
+using ExportedSymbol = std::tuple<SymbolKind, std::string, bool, bool>;
+using ExportedSymbolSeq = std::vector<ExportedSymbol>;
+
+inline bool operator<(const ExportedSymbol &lhs, const ExportedSymbol &rhs) {
+  return std::get<1>(lhs) < std::get<1>(rhs);
+}
+
+static ExportedSymbolSeq TBDv1Symbols = {
+    {SymbolKind::GlobalSymbol, "$ld$hide$os9.0$_sym1", false, false},
+    {SymbolKind::GlobalSymbol, "_sym1", false, false},
+    {SymbolKind::GlobalSymbol, "_sym2", false, false},
+    {SymbolKind::GlobalSymbol, "_sym3", false, false},
+    {SymbolKind::GlobalSymbol, "_sym4", false, false},
+    {SymbolKind::GlobalSymbol, "_sym5", false, false},
+    {SymbolKind::GlobalSymbol, "_tlv1", false, true},
+    {SymbolKind::GlobalSymbol, "_tlv2", false, true},
+    {SymbolKind::GlobalSymbol, "_tlv3", false, true},
+    {SymbolKind::GlobalSymbol, "_weak1", true, false},
+    {SymbolKind::GlobalSymbol, "_weak2", true, false},
+    {SymbolKind::GlobalSymbol, "_weak3", true, false},
+    {SymbolKind::ObjectiveCClass, "class1", false, false},
+    {SymbolKind::ObjectiveCClass, "class2", false, false},
+    {SymbolKind::ObjectiveCClass, "class3", false, false},
+    {SymbolKind::ObjectiveCInstanceVariable, "class1._ivar1", false, false},
+    {SymbolKind::ObjectiveCInstanceVariable, "class1._ivar2", false, false},
+    {SymbolKind::ObjectiveCInstanceVariable, "class1._ivar3", false, false},
+};
+
+namespace TBDv1 {
+
+TEST(TBDv1, ReadFile) {
+  static const char tbd_v1_file1[] =
+      "---\n"
+      "archs: [ armv7, armv7s, armv7k, arm64 ]\n"
+      "platform: ios\n"
+      "install-name: Test.dylib\n"
+      "current-version: 2.3.4\n"
+      "compatibility-version: 1.0\n"
+      "swift-version: 1.1\n"
+      "exports:\n"
+      "  - archs: [ armv7, armv7s, armv7k, arm64 ]\n"
+      "    allowed-clients: [ clientA ]\n"
+      "    re-exports: [ /usr/lib/libfoo.dylib ]\n"
+      "    symbols: [ _sym1, _sym2, _sym3, _sym4, $ld$hide$os9.0$_sym1 ]\n"
+      "    objc-classes: [ _class1, _class2 ]\n"
+      "    objc-ivars: [ _class1._ivar1, _class1._ivar2 ]\n"
+      "    weak-def-symbols: [ _weak1, _weak2 ]\n"
+      "    thread-local-symbols: [ _tlv1, _tlv2 ]\n"
+      "  - archs: [ armv7, armv7s, armv7k ]\n"
+      "    symbols: [ _sym5 ]\n"
+      "    objc-classes: [ _class3 ]\n"
+      "    objc-ivars: [ _class1._ivar3 ]\n"
+      "    weak-def-symbols: [ _weak3 ]\n"
+      "    thread-local-symbols: [ _tlv3 ]\n"
+      "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_file1, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V1, File->getFileType());
+  auto Archs = Architecture::armv7 | Architecture::armv7s |
+               Architecture::armv7k | Architecture::arm64;
+  EXPECT_EQ(Archs, File->getArchitectures());
+  EXPECT_EQ(Platform::iOS, File->getPlatform());
+  EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
+  EXPECT_EQ(PackedVersion(2, 3, 4), File->getCurrentVersion());
+  EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
+  EXPECT_EQ(2U, File->getSwiftABIVersion());
+  EXPECT_EQ(ObjCConstraint::None, File->getObjCConstraint());
+  EXPECT_TRUE(File->isTwoLevelNamespace());
+  EXPECT_TRUE(File->isApplicationExtensionSafe());
+  EXPECT_FALSE(File->isInstallAPI());
+  InterfaceFileRef client("clientA", Archs);
+  InterfaceFileRef reexport("/usr/lib/libfoo.dylib", Archs);
+  EXPECT_EQ(1U, File->allowableClients().size());
+  EXPECT_EQ(client, File->allowableClients().front());
+  EXPECT_EQ(1U, File->reexportedLibraries().size());
+  EXPECT_EQ(reexport, File->reexportedLibraries().front());
+
+  ExportedSymbolSeq Exports;
+  for (const auto *Sym : File->symbols()) {
+    EXPECT_FALSE(Sym->isWeakReferenced());
+    EXPECT_FALSE(Sym->isUndefined());
+    Exports.emplace_back(Sym->getKind(), Sym->getName(), Sym->isWeakDefined(),
+                         Sym->isThreadLocalValue());
+  }
+  llvm::sort(Exports.begin(), Exports.end());
+
+  EXPECT_EQ(TBDv1Symbols.size(), Exports.size());
+  EXPECT_TRUE(std::equal(Exports.begin(), Exports.end(), TBDv1Symbols.begin()));
+}
+
+TEST(TBDv1, ReadFile2) {
+  static const char tbd_v1_file2[] = "--- !tapi-tbd-v1\n"
+                                     "archs: [ armv7, armv7s, armv7k, arm64 ]\n"
+                                     "platform: ios\n"
+                                     "install-name: Test.dylib\n"
+                                     "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_file2, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V1, File->getFileType());
+  auto Archs = Architecture::armv7 | Architecture::armv7s |
+               Architecture::armv7k | Architecture::arm64;
+  EXPECT_EQ(Archs, File->getArchitectures());
+  EXPECT_EQ(Platform::iOS, File->getPlatform());
+  EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
+  EXPECT_EQ(PackedVersion(1, 0, 0), File->getCurrentVersion());
+  EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
+  EXPECT_EQ(0U, File->getSwiftABIVersion());
+  EXPECT_EQ(ObjCConstraint::None, File->getObjCConstraint());
+  EXPECT_TRUE(File->isTwoLevelNamespace());
+  EXPECT_TRUE(File->isApplicationExtensionSafe());
+  EXPECT_FALSE(File->isInstallAPI());
+  EXPECT_EQ(0U, File->allowableClients().size());
+  EXPECT_EQ(0U, File->reexportedLibraries().size());
+}
+
+TEST(TBDv1, WriteFile) {
+  static const char tbd_v1_file3[] =
+      "---\n"
+      "archs:           [ i386, x86_64 ]\n"
+      "platform:        macosx\n"
+      "install-name:    '/usr/lib/libfoo.dylib'\n"
+      "current-version: 1.2.3\n"
+      "compatibility-version: 0\n"
+      "swift-version:   5\n"
+      "objc-constraint: retain_release\n"
+      "exports:         \n"
+      "  - archs:           [ i386 ]\n"
+      "    symbols:         [ _sym1 ]\n"
+      "    weak-def-symbols: [ _sym2 ]\n"
+      "    thread-local-symbols: [ _sym3 ]\n"
+      "  - archs:           [ x86_64 ]\n"
+      "    allowed-clients: [ clientA ]\n"
+      "    re-exports:      [ '/usr/lib/libfoo.dylib' ]\n"
+      "    symbols:         [ '_OBJC_EHTYPE_$_Class1' ]\n"
+      "    objc-classes:    [ _Class1 ]\n"
+      "    objc-ivars:      [ _Class1._ivar1 ]\n"
+      "...\n";
+
+  InterfaceFile File;
+  File.setPath("libfoo.dylib");
+  File.setInstallName("/usr/lib/libfoo.dylib");
+  File.setFileType(FileType::TBD_V1);
+  File.setArchitectures(Architecture::i386 | Architecture::x86_64);
+  File.setPlatform(Platform::macOS);
+  File.setCurrentVersion(PackedVersion(1, 2, 3));
+  File.setSwiftABIVersion(5);
+  File.setObjCConstraint(ObjCConstraint::Retain_Release);
+  File.addAllowableClient("clientA", Architecture::x86_64);
+  File.addReexportedLibrary("/usr/lib/libfoo.dylib", Architecture::x86_64);
+  File.addSymbol(SymbolKind::GlobalSymbol, "_sym1", Architecture::i386);
+  File.addSymbol(SymbolKind::GlobalSymbol, "_sym2", Architecture::i386,
+                 SymbolFlags::WeakDefined);
+  File.addSymbol(SymbolKind::GlobalSymbol, "_sym3", Architecture::i386,
+                 SymbolFlags::ThreadLocalValue);
+  File.addSymbol(SymbolKind::ObjectiveCClass, "Class1", Architecture::x86_64);
+  File.addSymbol(SymbolKind::ObjectiveCClassEHType, "Class1",
+                 Architecture::x86_64);
+  File.addSymbol(SymbolKind::ObjectiveCInstanceVariable, "Class1._ivar1",
+                 Architecture::x86_64);
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto Result = TextAPIWriter::writeToStream(OS, File);
+  EXPECT_FALSE(Result);
+  EXPECT_STREQ(tbd_v1_file3, Buffer.c_str());
+}
+
+TEST(TBDv1, Platform_macOS) {
+  static const char tbd_v1_platform_macos[] = "---\n"
+                                              "archs: [ x86_64 ]\n"
+                                              "platform: macosx\n"
+                                              "install-name: Test.dylib\n"
+                                              "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_macos, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V1, File->getFileType());
+  EXPECT_EQ(Platform::macOS, File->getPlatform());
+}
+
+TEST(TBDv1, Platform_iOS) {
+  static const char tbd_v1_platform_ios[] = "---\n"
+                                            "archs: [ arm64 ]\n"
+                                            "platform: ios\n"
+                                            "install-name: Test.dylib\n"
+                                            "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_ios, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V1, File->getFileType());
+  EXPECT_EQ(Platform::iOS, File->getPlatform());
+}
+
+TEST(TBDv1, Platform_watchOS) {
+  static const char tbd_v1_platform_watchos[] = "---\n"
+                                                "archs: [ armv7k ]\n"
+                                                "platform: watchos\n"
+                                                "install-name: Test.dylib\n"
+                                                "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_watchos, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V1, File->getFileType());
+  EXPECT_EQ(Platform::watchOS, File->getPlatform());
+}
+
+TEST(TBDv1, Platform_tvOS) {
+  static const char tbd_v1_platform_tvos[] = "---\n"
+                                             "archs: [ arm64 ]\n"
+                                             "platform: tvos\n"
+                                             "install-name: Test.dylib\n"
+                                             "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_tvos, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V1, File->getFileType());
+  EXPECT_EQ(Platform::tvOS, File->getPlatform());
+}
+
+TEST(TBDv1, Platform_bridgeOS) {
+  static const char tbd_v1_platform_bridgeos[] = "---\n"
+                                                 "archs: [ armv7k ]\n"
+                                                 "platform: bridgeos\n"
+                                                 "install-name: Test.dylib\n"
+                                                 "...\n";
+
+  auto Buffer =
+      MemoryBuffer::getMemBuffer(tbd_v1_platform_bridgeos, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V1, File->getFileType());
+  EXPECT_EQ(Platform::bridgeOS, File->getPlatform());
+}
+
+TEST(TBDv1, Swift_1_0) {
+  static const char tbd_v1_swift_1_0[] = "---\n"
+                                         "archs: [ arm64 ]\n"
+                                         "platform: ios\n"
+                                         "install-name: Test.dylib\n"
+                                         "swift-version: 1.0\n"
+                                         "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_1_0, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V1, File->getFileType());
+  EXPECT_EQ(1U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv1, Swift_1_1) {
+  static const char tbd_v1_swift_1_1[] = "---\n"
+                                         "archs: [ arm64 ]\n"
+                                         "platform: ios\n"
+                                         "install-name: Test.dylib\n"
+                                         "swift-version: 1.1\n"
+                                         "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_1_1, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V1, File->getFileType());
+  EXPECT_EQ(2U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv1, Swift_2_0) {
+  static const char tbd_v1_swift_2_0[] = "---\n"
+                                         "archs: [ arm64 ]\n"
+                                         "platform: ios\n"
+                                         "install-name: Test.dylib\n"
+                                         "swift-version: 2.0\n"
+                                         "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_2_0, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V1, File->getFileType());
+  EXPECT_EQ(3U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv1, Swift_3_0) {
+  static const char tbd_v1_swift_3_0[] = "---\n"
+                                         "archs: [ arm64 ]\n"
+                                         "platform: ios\n"
+                                         "install-name: Test.dylib\n"
+                                         "swift-version: 3.0\n"
+                                         "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_3_0, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V1, File->getFileType());
+  EXPECT_EQ(4U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv1, Swift_4_0) {
+  static const char tbd_v1_swift_4_0[] = "---\n"
+                                         "archs: [ arm64 ]\n"
+                                         "platform: ios\n"
+                                         "install-name: Test.dylib\n"
+                                         "swift-version: 4.0\n"
+                                         "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_4_0, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_FALSE(!!Result);
+  auto errorMessage = toString(Result.takeError());
+  EXPECT_EQ("malformed file\nTest.tbd:5:16: error: invalid Swift ABI "
+            "version.\nswift-version: 4.0\n               ^~~\n",
+            errorMessage);
+}
+
+TEST(TBDv1, Swift_5) {
+  static const char tbd_v1_swift_5[] = "---\n"
+                                       "archs: [ arm64 ]\n"
+                                       "platform: ios\n"
+                                       "install-name: Test.dylib\n"
+                                       "swift-version: 5\n"
+                                       "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_5, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V1, File->getFileType());
+  EXPECT_EQ(5U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv1, Swift_99) {
+  static const char tbd_v1_swift_99[] = "---\n"
+                                        "archs: [ arm64 ]\n"
+                                        "platform: ios\n"
+                                        "install-name: Test.dylib\n"
+                                        "swift-version: 99\n"
+                                        "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_99, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V1, File->getFileType());
+  EXPECT_EQ(99U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv1, UnknownArchitecture) {
+  static const char tbd_v1_file_unknown_architecture[] =
+      "---\n"
+      "archs: [ foo ]\n"
+      "platform: macosx\n"
+      "install-name: Test.dylib\n"
+      "...\n";
+
+  auto Buffer =
+      MemoryBuffer::getMemBuffer(tbd_v1_file_unknown_architecture, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+}
+
+TEST(TBDv1, UnknownPlatform) {
+  static const char tbd_v1_file_unknown_platform[] = "---\n"
+                                                     "archs: [ i386 ]\n"
+                                                     "platform: newOS\n"
+                                                     "...\n";
+
+  auto Buffer =
+      MemoryBuffer::getMemBuffer(tbd_v1_file_unknown_platform, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_FALSE(!!Result);
+  auto errorMessage = toString(Result.takeError());
+  EXPECT_EQ("malformed file\nTest.tbd:3:11: error: unknown platform\nplatform: "
+            "newOS\n          ^~~~~\n",
+            errorMessage);
+}
+
+TEST(TBDv1, MalformedFile1) {
+  static const char malformed_file1[] = "---\n"
+                                        "archs: [ arm64 ]\n"
+                                        "foobar: \"Unsupported key\"\n"
+                                        "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(malformed_file1, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_FALSE(!!Result);
+  auto errorMessage = toString(Result.takeError());
+  ASSERT_EQ("malformed file\nTest.tbd:2:1: error: missing required key "
+            "'platform'\narchs: [ arm64 ]\n^\n",
+            errorMessage);
+}
+
+TEST(TBDv1, MalformedFile2) {
+  static const char malformed_file2[] = "---\n"
+                                        "archs: [ arm64 ]\n"
+                                        "platform: ios\n"
+                                        "install-name: Test.dylib\n"
+                                        "foobar: \"Unsupported key\"\n"
+                                        "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(malformed_file2, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  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);
+}
+
+} // end namespace TBDv1.

llvm/unittests/TextAPI/TextStubV2Tests.cpp

+//===-- TextStubV2Tests.cpp - TBD V2 File Test ----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#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;
+
+using ExportedSymbol = std::tuple<SymbolKind, std::string, bool, bool>;
+using ExportedSymbolSeq = std::vector<ExportedSymbol>;
+
+inline bool operator<(const ExportedSymbol &lhs, const ExportedSymbol &rhs) {
+  return std::get<1>(lhs) < std::get<1>(rhs);
+}
+
+static ExportedSymbolSeq TBDv2Symbols = {
+    {SymbolKind::GlobalSymbol, "$ld$hide$os9.0$_sym1", false, false},
+    {SymbolKind::GlobalSymbol, "_sym1", false, false},
+    {SymbolKind::GlobalSymbol, "_sym2", false, false},
+    {SymbolKind::GlobalSymbol, "_sym3", false, false},
+    {SymbolKind::GlobalSymbol, "_sym4", false, false},
+    {SymbolKind::GlobalSymbol, "_sym5", false, false},
+    {SymbolKind::GlobalSymbol, "_tlv1", false, true},
+    {SymbolKind::GlobalSymbol, "_tlv2", false, true},
+    {SymbolKind::GlobalSymbol, "_tlv3", false, true},
+    {SymbolKind::GlobalSymbol, "_weak1", true, false},
+    {SymbolKind::GlobalSymbol, "_weak2", true, false},
+    {SymbolKind::GlobalSymbol, "_weak3", true, false},
+    {SymbolKind::ObjectiveCClass, "class1", false, false},
+    {SymbolKind::ObjectiveCClass, "class2", false, false},
+    {SymbolKind::ObjectiveCClass, "class3", false, false},
+    {SymbolKind::ObjectiveCInstanceVariable, "class1._ivar1", false, false},
+    {SymbolKind::ObjectiveCInstanceVariable, "class1._ivar2", false, false},
+    {SymbolKind::ObjectiveCInstanceVariable, "class1._ivar3", false, false},
+};
+
+namespace TBDv2 {
+
+TEST(TBDv2, ReadFile) {
+  static const char tbd_v2_file1[] =
+      "--- !tapi-tbd-v2\n"
+      "archs: [ armv7, armv7s, armv7k, arm64 ]\n"
+      "platform: ios\n"
+      "flags: [ installapi ]\n"
+      "install-name: Test.dylib\n"
+      "current-version: 2.3.4\n"
+      "compatibility-version: 1.0\n"
+      "swift-version: 1.1\n"
+      "parent-umbrella: Umbrella.dylib\n"
+      "exports:\n"
+      "  - archs: [ armv7, armv7s, armv7k, arm64 ]\n"
+      "    allowable-clients: [ clientA ]\n"
+      "    re-exports: [ /usr/lib/libfoo.dylib ]\n"
+      "    symbols: [ _sym1, _sym2, _sym3, _sym4, $ld$hide$os9.0$_sym1 ]\n"
+      "    objc-classes: [ _class1, _class2 ]\n"
+      "    objc-ivars: [ _class1._ivar1, _class1._ivar2 ]\n"
+      "    weak-def-symbols: [ _weak1, _weak2 ]\n"
+      "    thread-local-symbols: [ _tlv1, _tlv2 ]\n"
+      "  - archs: [ armv7, armv7s, armv7k ]\n"
+      "    symbols: [ _sym5 ]\n"
+      "    objc-classes: [ _class3 ]\n"
+      "    objc-ivars: [ _class1._ivar3 ]\n"
+      "    weak-def-symbols: [ _weak3 ]\n"
+      "    thread-local-symbols: [ _tlv3 ]\n"
+      "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v2_file1, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V2, File->getFileType());
+  auto Archs = Architecture::armv7 | Architecture::armv7s |
+               Architecture::armv7k | Architecture::arm64;
+  EXPECT_EQ(Archs, File->getArchitectures());
+  EXPECT_EQ(Platform::iOS, File->getPlatform());
+  EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
+  EXPECT_EQ(PackedVersion(2, 3, 4), File->getCurrentVersion());
+  EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
+  EXPECT_EQ(2U, File->getSwiftABIVersion());
+  EXPECT_EQ(ObjCConstraint::Retain_Release, File->getObjCConstraint());
+  EXPECT_TRUE(File->isTwoLevelNamespace());
+  EXPECT_TRUE(File->isApplicationExtensionSafe());
+  EXPECT_TRUE(File->isInstallAPI());
+  InterfaceFileRef client("clientA", Archs);
+  InterfaceFileRef reexport("/usr/lib/libfoo.dylib", Archs);
+  EXPECT_EQ(1U, File->allowableClients().size());
+  EXPECT_EQ(client, File->allowableClients().front());
+  EXPECT_EQ(1U, File->reexportedLibraries().size());
+  EXPECT_EQ(reexport, File->reexportedLibraries().front());
+
+  ExportedSymbolSeq Exports;
+  for (const auto *Sym : File->symbols()) {
+    EXPECT_FALSE(Sym->isWeakReferenced());
+    EXPECT_FALSE(Sym->isUndefined());
+    Exports.emplace_back(Sym->getKind(), Sym->getName(), Sym->isWeakDefined(),
+                         Sym->isThreadLocalValue());
+  }
+  llvm::sort(Exports.begin(), Exports.end());
+
+  EXPECT_EQ(TBDv2Symbols.size(), Exports.size());
+  EXPECT_TRUE(std::equal(Exports.begin(), Exports.end(), TBDv2Symbols.begin()));
+}
+
+TEST(TBDv2, ReadFile2) {
+  static const char tbd_v2_file2[] =
+      "--- !tapi-tbd-v2\n"
+      "archs: [ armv7, armv7s, armv7k, arm64 ]\n"
+      "platform: ios\n"
+      "flags: [ flat_namespace, not_app_extension_safe ]\n"
+      "install-name: Test.dylib\n"
+      "swift-version: 1.1\n"
+      "exports:\n"
+      "  - archs: [ armv7, armv7s, armv7k, arm64 ]\n"
+      "    symbols: [ _sym1, _sym2, _sym3, _sym4, $ld$hide$os9.0$_sym1 ]\n"
+      "    objc-classes: [ _class1, _class2 ]\n"
+      "    objc-ivars: [ _class1._ivar1, _class1._ivar2 ]\n"
+      "    weak-def-symbols: [ _weak1, _weak2 ]\n"
+      "    thread-local-symbols: [ _tlv1, _tlv2 ]\n"
+      "  - archs: [ armv7, armv7s, armv7k ]\n"
+      "    symbols: [ _sym5 ]\n"
+      "    objc-classes: [ _class3 ]\n"
+      "    objc-ivars: [ _class1._ivar3 ]\n"
+      "    weak-def-symbols: [ _weak3 ]\n"
+      "    thread-local-symbols: [ _tlv3 ]\n"
+      "undefineds:\n"
+      "  - archs: [ armv7, armv7s, armv7k, arm64 ]\n"
+      "    symbols: [ _undefSym1, _undefSym2, _undefSym3 ]\n"
+      "    objc-classes: [ _undefClass1, _undefClass2 ]\n"
+      "    objc-ivars: [ _undefClass1._ivar1, _undefClass1._ivar2 ]\n"
+      "    weak-ref-symbols: [ _undefWeak1, _undefWeak2 ]\n"
+      "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v2_file2, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V2, File->getFileType());
+  auto Archs = Architecture::armv7 | Architecture::armv7s |
+               Architecture::armv7k | Architecture::arm64;
+  EXPECT_EQ(Archs, File->getArchitectures());
+  EXPECT_EQ(Platform::iOS, File->getPlatform());
+  EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
+  EXPECT_EQ(PackedVersion(1, 0, 0), File->getCurrentVersion());
+  EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
+  EXPECT_EQ(2U, File->getSwiftABIVersion());
+  EXPECT_EQ(ObjCConstraint::Retain_Release, File->getObjCConstraint());
+  EXPECT_FALSE(File->isTwoLevelNamespace());
+  EXPECT_FALSE(File->isApplicationExtensionSafe());
+  EXPECT_FALSE(File->isInstallAPI());
+  EXPECT_EQ(0U, File->allowableClients().size());
+  EXPECT_EQ(0U, File->reexportedLibraries().size());
+}
+
+TEST(TBDv2, WriteFile) {
+  static const char tbd_v2_file3[] =
+      "--- !tapi-tbd-v2\n"
+      "archs:           [ i386, x86_64 ]\n"
+      "platform:        macosx\n"
+      "install-name:    '/usr/lib/libfoo.dylib'\n"
+      "current-version: 1.2.3\n"
+      "compatibility-version: 0\n"
+      "swift-version:   5\n"
+      "exports:         \n"
+      "  - archs:           [ i386 ]\n"
+      "    symbols:         [ _sym1 ]\n"
+      "    weak-def-symbols: [ _sym2 ]\n"
+      "    thread-local-symbols: [ _sym3 ]\n"
+      "  - archs:           [ x86_64 ]\n"
+      "    allowable-clients: [ clientA ]\n"
+      "    re-exports:      [ '/usr/lib/libfoo.dylib' ]\n"
+      "    symbols:         [ '_OBJC_EHTYPE_$_Class1' ]\n"
+      "    objc-classes:    [ _Class1 ]\n"
+      "    objc-ivars:      [ _Class1._ivar1 ]\n"
+      "...\n";
+
+  InterfaceFile File;
+  File.setPath("libfoo.dylib");
+  File.setInstallName("/usr/lib/libfoo.dylib");
+  File.setFileType(FileType::TBD_V2);
+  File.setArchitectures(Architecture::i386 | Architecture::x86_64);
+  File.setPlatform(Platform::macOS);
+  File.setCurrentVersion(PackedVersion(1, 2, 3));
+  File.setTwoLevelNamespace();
+  File.setApplicationExtensionSafe();
+  File.setSwiftABIVersion(5);
+  File.setObjCConstraint(ObjCConstraint::Retain_Release);
+  File.addAllowableClient("clientA", Architecture::x86_64);
+  File.addReexportedLibrary("/usr/lib/libfoo.dylib", Architecture::x86_64);
+  File.addSymbol(SymbolKind::GlobalSymbol, "_sym1", Architecture::i386);
+  File.addSymbol(SymbolKind::GlobalSymbol, "_sym2", Architecture::i386,
+                 SymbolFlags::WeakDefined);
+  File.addSymbol(SymbolKind::GlobalSymbol, "_sym3", Architecture::i386,
+                 SymbolFlags::ThreadLocalValue);
+  File.addSymbol(SymbolKind::ObjectiveCClass, "Class1", Architecture::x86_64);
+  File.addSymbol(SymbolKind::ObjectiveCClassEHType, "Class1",
+                 Architecture::x86_64);
+  File.addSymbol(SymbolKind::ObjectiveCInstanceVariable, "Class1._ivar1",
+                 Architecture::x86_64);
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto Result = TextAPIWriter::writeToStream(OS, File);
+  EXPECT_FALSE(Result);
+  EXPECT_STREQ(tbd_v2_file3, Buffer.c_str());
+}
+
+TEST(TBDv2, Platform_macOS) {
+  static const char tbd_v1_platform_macos[] = "--- !tapi-tbd-v2\n"
+                                              "archs: [ x86_64 ]\n"
+                                              "platform: macosx\n"
+                                              "install-name: Test.dylib\n"
+                                              "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_macos, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V2, File->getFileType());
+  EXPECT_EQ(Platform::macOS, File->getPlatform());
+}
+
+TEST(TBDv2, Platform_iOS) {
+  static const char tbd_v1_platform_ios[] = "--- !tapi-tbd-v2\n"
+                                            "archs: [ arm64 ]\n"
+                                            "platform: ios\n"
+                                            "install-name: Test.dylib\n"
+                                            "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_ios, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V2, File->getFileType());
+  EXPECT_EQ(Platform::iOS, File->getPlatform());
+}
+
+TEST(TBDv2, Platform_watchOS) {
+  static const char tbd_v1_platform_watchos[] = "--- !tapi-tbd-v2\n"
+                                                "archs: [ armv7k ]\n"
+                                                "platform: watchos\n"
+                                                "install-name: Test.dylib\n"
+                                                "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_watchos, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V2, File->getFileType());
+  EXPECT_EQ(Platform::watchOS, File->getPlatform());
+}
+
+TEST(TBDv2, Platform_tvOS) {
+  static const char tbd_v1_platform_tvos[] = "--- !tapi-tbd-v2\n"
+                                             "archs: [ arm64 ]\n"
+                                             "platform: tvos\n"
+                                             "install-name: Test.dylib\n"
+                                             "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_tvos, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V2, File->getFileType());
+  EXPECT_EQ(Platform::tvOS, File->getPlatform());
+}
+
+TEST(TBDv2, Platform_bridgeOS) {
+  static const char tbd_v1_platform_bridgeos[] = "--- !tapi-tbd-v2\n"
+                                                 "archs: [ armv7k ]\n"
+                                                 "platform: bridgeos\n"
+                                                 "install-name: Test.dylib\n"
+                                                 "...\n";
+
+  auto Buffer =
+      MemoryBuffer::getMemBuffer(tbd_v1_platform_bridgeos, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V2, File->getFileType());
+  EXPECT_EQ(Platform::bridgeOS, File->getPlatform());
+}
+
+TEST(TBDv2, Swift_1_0) {
+  static const char tbd_v1_swift_1_0[] = "--- !tapi-tbd-v2\n"
+                                         "archs: [ arm64 ]\n"
+                                         "platform: ios\n"
+                                         "install-name: Test.dylib\n"
+                                         "swift-version: 1.0\n"
+                                         "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_1_0, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V2, File->getFileType());
+  EXPECT_EQ(1U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv2, Swift_1_1) {
+  static const char tbd_v1_swift_1_1[] = "--- !tapi-tbd-v2\n"
+                                         "archs: [ arm64 ]\n"
+                                         "platform: ios\n"
+                                         "install-name: Test.dylib\n"
+                                         "swift-version: 1.1\n"
+                                         "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_1_1, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V2, File->getFileType());
+  EXPECT_EQ(2U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv2, Swift_2_0) {
+  static const char tbd_v1_swift_2_0[] = "--- !tapi-tbd-v2\n"
+                                         "archs: [ arm64 ]\n"
+                                         "platform: ios\n"
+                                         "install-name: Test.dylib\n"
+                                         "swift-version: 2.0\n"
+                                         "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_2_0, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V2, File->getFileType());
+  EXPECT_EQ(3U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv2, Swift_3_0) {
+  static const char tbd_v1_swift_3_0[] = "--- !tapi-tbd-v2\n"
+                                         "archs: [ arm64 ]\n"
+                                         "platform: ios\n"
+                                         "install-name: Test.dylib\n"
+                                         "swift-version: 3.0\n"
+                                         "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_3_0, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V2, File->getFileType());
+  EXPECT_EQ(4U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv2, Swift_4_0) {
+  static const char tbd_v1_swift_4_0[] = "--- !tapi-tbd-v2\n"
+                                         "archs: [ arm64 ]\n"
+                                         "platform: ios\n"
+                                         "install-name: Test.dylib\n"
+                                         "swift-version: 4.0\n"
+                                         "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_4_0, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_FALSE(!!Result);
+  auto errorMessage = toString(Result.takeError());
+  EXPECT_EQ("malformed file\nTest.tbd:5:16: error: invalid Swift ABI "
+            "version.\nswift-version: 4.0\n               ^~~\n",
+            errorMessage);
+}
+
+TEST(TBDv2, Swift_5) {
+  static const char tbd_v1_swift_5[] = "--- !tapi-tbd-v2\n"
+                                       "archs: [ arm64 ]\n"
+                                       "platform: ios\n"
+                                       "install-name: Test.dylib\n"
+                                       "swift-version: 5\n"
+                                       "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_5, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V2, File->getFileType());
+  EXPECT_EQ(5U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv2, Swift_99) {
+  static const char tbd_v1_swift_99[] = "--- !tapi-tbd-v2\n"
+                                        "archs: [ arm64 ]\n"
+                                        "platform: ios\n"
+                                        "install-name: Test.dylib\n"
+                                        "swift-version: 99\n"
+                                        "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_99, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+  auto File = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V2, File->getFileType());
+  EXPECT_EQ(99U, File->getSwiftABIVersion());
+}
+
+TEST(TBDv2, UnknownArchitecture) {
+  static const char tbd_v2_file_unknown_architecture[] =
+      "--- !tapi-tbd-v2\n"
+      "archs: [ foo ]\n"
+      "platform: macosx\n"
+      "install-name: Test.dylib\n"
+      "...\n";
+
+  auto Buffer =
+      MemoryBuffer::getMemBuffer(tbd_v2_file_unknown_architecture, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_TRUE(!!Result);
+}
+
+TEST(TBDv2, UnknownPlatform) {
+  static const char tbd_v2_file_unknown_platform[] = "--- !tapi-tbd-v2\n"
+                                                     "archs: [ i386 ]\n"
+                                                     "platform: newOS\n"
+                                                     "...\n";
+
+  auto Buffer =
+      MemoryBuffer::getMemBuffer(tbd_v2_file_unknown_platform, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_FALSE(!!Result);
+  auto errorMessage = toString(Result.takeError());
+  EXPECT_EQ("malformed file\nTest.tbd:3:11: error: unknown platform\nplatform: "
+            "newOS\n          ^~~~~\n",
+            errorMessage);
+}
+
+TEST(TBDv2, MalformedFile1) {
+  static const char malformed_file1[] = "--- !tapi-tbd-v2\n"
+                                        "archs: [ arm64 ]\n"
+                                        "foobar: \"Unsupported key\"\n"
+                                        "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(malformed_file1, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  EXPECT_FALSE(!!Result);
+  auto errorMessage = toString(Result.takeError());
+  ASSERT_EQ("malformed file\nTest.tbd:2:1: error: missing required key "
+            "'platform'\narchs: [ arm64 ]\n^\n",
+            errorMessage);
+}
+
+TEST(TBDv2, MalformedFile2) {
+  static const char malformed_file2[] = "--- !tapi-tbd-v2\n"
+                                        "archs: [ arm64 ]\n"
+                                        "platform: ios\n"
+                                        "install-name: Test.dylib\n"
+                                        "foobar: \"Unsupported key\"\n"
+                                        "...\n";
+
+  auto Buffer = MemoryBuffer::getMemBuffer(malformed_file2, "Test.tbd");
+  auto Result = TextAPIReader::get(std::move(Buffer));
+  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);
+}
+
+} // namespace TBDv2