[TextAPI] Capture new properties from TBD to InterfaceFile

[cishida]

Summary

• Deployment Versions for targets
• Run Search Paths
• Text vs Data Segment attributes to symbols

[cishida]

Rebase changes

[cishida]

Fix typo

[cishida]

Fix printing for unknown deployment verison in older TBDs.

[cishida]

Rebase

[pete]

LGTM

llvm/include/llvm/TextAPI/InterfaceFile.h

public:
 
   /// Get the list of inlined libraries.
   ///
   /// \return Returns a list of the inlined frameworks.
   const std::vector<std::shared_ptr<InterfaceFile>> &documents() const {
     return Documents;
   }
 
+  /// Set the runpath search paths.
+  /// \param Target_ The target applicable to runpath search path.
+  /// \param RPath The name of runpath.
+  void addRPath(const Target &InputTarget, StringRef RPath);
+
+  /// Get the list of runpath search paths.
+  ///
+  /// \return Returns a list of the rpaths per target.
+  const std::vector<std::pair<Target, std::string>> &rpaths() const {
+    return RPaths;
+  }
+
   /// Add a symbol to the symbols list or extend an existing one.
   void addSymbol(SymbolKind Kind, StringRef Name, const TargetList &Targets,
                  SymbolFlags Flags = SymbolFlags::None);
 
   using SymbolMapType = DenseMap<SymbolsMapKey, Symbol *>;
   struct const_symbol_iterator
       : public iterator_adaptor_base<
             const_symbol_iterator, SymbolMapType::const_iterator,
private:
   bool IsAppExtensionSafe{false};
   bool IsInstallAPI{false};
   ObjCConstraintType ObjcConstraint = ObjCConstraintType::None;
   std::vector<std::pair<Target, std::string>> ParentUmbrellas;
   std::vector<InterfaceFileRef> AllowableClients;
   std::vector<InterfaceFileRef> ReexportedLibraries;
   std::vector<std::shared_ptr<InterfaceFile>> Documents;
   std::vector<std::pair<Target, std::string>> UUIDs;
+  std::vector<std::pair<Target, std::string>> RPaths;
   SymbolMapType Symbols;
   InterfaceFile *Parent = nullptr;
 };
 
 template <typename DerivedT, typename KeyInfoT, typename BucketT>
 bool operator==(const DenseMapBase<DerivedT, SymbolsMapKey, MachO::Symbol *,
                                    KeyInfoT, BucketT> &LHS,
                 const DenseMapBase<DerivedT, SymbolsMapKey, MachO::Symbol *,

llvm/include/llvm/TextAPI/Symbol.h

enum class SymbolFlags : uint8_t {
   WeakReferenced   = 1U << 2,
 
   /// Undefined
   Undefined        = 1U << 3,
 
   /// Rexported
   Rexported        = 1U << 4,
 
-  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Rexported),
+  /// Data Segment  
+  Data             = 1U << 5,
+
+  /// Text Segment
+  Text             = 1U << 6,
+  
+  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Text),
 };
 
 // clang-format on
 
 enum class SymbolKind : uint8_t {
   GlobalSymbol,
   ObjectiveCClass,
   ObjectiveCClassEHType,
public:
   bool isUndefined() const {
     return (Flags & SymbolFlags::Undefined) == SymbolFlags::Undefined;
   }
 
   bool isReexported() const {
     return (Flags & SymbolFlags::Rexported) == SymbolFlags::Rexported;
   }
 
+  bool isData() const {
+    return (Flags & SymbolFlags::Data) == SymbolFlags::Data;
+  }
+
+  bool isText() const {
+    return (Flags & SymbolFlags::Text) == SymbolFlags::Text;
+  }
+
   using const_target_iterator = TargetList::const_iterator;
   using const_target_range = llvm::iterator_range<const_target_iterator>;
   const_target_range targets() const { return {Targets}; }
 
   using const_filtered_target_iterator =
       llvm::filter_iterator<const_target_iterator,
                             std::function<bool(const Target &)>>;
   using const_filtered_target_range =

llvm/include/llvm/TextAPI/Target.h

 //===- llvm/TextAPI/Target.h - TAPI Target ----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TEXTAPI_TARGET_H
 #define LLVM_TEXTAPI_TARGET_H
 
 #include "llvm/Support/Error.h"
+#include "llvm/Support/VersionTuple.h"
+#include "llvm/TargetParser/Triple.h"
 #include "llvm/TextAPI/Architecture.h"
 #include "llvm/TextAPI/ArchitectureSet.h"
 #include "llvm/TextAPI/Platform.h"
 
 namespace llvm {
 
 class Triple;
 
 namespace MachO {
 
 // This is similar to a llvm Triple, but the triple doesn't have all the
 // information we need. For example there is no enum value for x86_64h. The
 // only way to get that information is to parse the triple string.
 class Target {
 public:
   Target() = default;
-  Target(Architecture Arch, PlatformType Platform)
-      : Arch(Arch), Platform(Platform) {}
+  Target(Architecture Arch, PlatformType Platform,
+         VersionTuple MinDeployment = {})
+      : Arch(Arch), Platform(Platform), MinDeployment(MinDeployment) {}
   explicit Target(const llvm::Triple &Triple)
-      : Arch(mapToArchitecture(Triple)), Platform(mapToPlatformType(Triple)) {}
+      : Arch(mapToArchitecture(Triple)), Platform(mapToPlatformType(Triple)),
+        MinDeployment(Triple.getOSVersion()) {}
 
   static llvm::Expected<Target> create(StringRef Target);
 
   operator std::string() const;
 
   Architecture Arch;
   PlatformType Platform;
+  VersionTuple MinDeployment;
 };
 
 inline bool operator==(const Target &LHS, const Target &RHS) {
   return std::tie(LHS.Arch, LHS.Platform) == std::tie(RHS.Arch, RHS.Platform);
 }
 
 inline bool operator!=(const Target &LHS, const Target &RHS) {
   return std::tie(LHS.Arch, LHS.Platform) != std::tie(RHS.Arch, RHS.Platform);

llvm/lib/TextAPI/InterfaceFile.cpp

void InterfaceFile::addParentUmbrella(const Target &Target_, StringRef Parent) {
   if ((Iter != ParentUmbrellas.end()) && !(Target_ < Iter->first)) {
     Iter->second = std::string(Parent);
     return;
   }
 
   ParentUmbrellas.emplace(Iter, Target_, std::string(Parent));
 }
 
+void InterfaceFile::addRPath(const Target &InputTarget, StringRef RPath) {
+  auto Iter = lower_bound(RPaths, InputTarget,
+                          [](const std::pair<Target, std::string> &LHS,
+                             Target RHS) { return LHS.first < RHS; });
+
+  if ((Iter != RPaths.end()) && !(InputTarget < Iter->first)) {
+    Iter->second = std::string(RPath);
+    return;
+  }
+
+  RPaths.emplace(Iter, InputTarget, std::string(RPath));
+}
+
 void InterfaceFile::addUUID(const Target &Target_, StringRef UUID) {
   auto Iter = lower_bound(UUIDs, Target_,
                           [](const std::pair<Target, std::string> &LHS,
                              Target RHS) { return LHS.first < RHS; });
 
   if ((Iter != UUIDs.end()) && !(Target_ < Iter->first)) {
     Iter->second = std::string(UUID);
     return;

llvm/lib/TextAPI/Target.cpp

if (PlatformStr.startswith("<") && PlatformStr.endswith(">")) {
         Platform = (PlatformType)RawValue;
     }
   }
 
   return Target{Architecture, Platform};
 }
 
 Target::operator std::string() const {
-  return (getArchitectureName(Arch) + " (" + getPlatformName(Platform) + ")")
+  return (getArchitectureName(Arch) + " (" + getPlatformName(Platform) +
+          MinDeployment.getAsString() + ")")
       .str();
 }
 
 raw_ostream &operator<<(raw_ostream &OS, const Target &Target) {
   OS << std::string(Target);
   return OS;
 }
 
 PlatformSet mapToPlatformSet(ArrayRef<Target> Targets) {
   PlatformSet Result;
   for (const auto &Target : Targets)
     Result.insert(Target.Platform);
   return Result;
 }
 
 ArchitectureSet mapToArchitectureSet(ArrayRef<Target> Targets) {
   ArchitectureSet Result;
   for (const auto &Target : Targets)
     Result.set(Target.Arch);
   return Result;
 }
 
 std::string getTargetTripleName(const Target &Targ) {
   return (getArchitectureName(Targ.Arch) + "-apple-" +
-          getOSAndEnvironmentName(Targ.Platform))
+          getOSAndEnvironmentName(Targ.Platform) +
+          Targ.MinDeployment.getAsString())
       .str();
 }
 
 } // end namespace MachO.
 } // end namespace llvm.

llvm/lib/TextAPI/TextStubV5.cpp

enum TBDKey : size_t {
   Data,
   Text,
   Weak,
   ThreadLocal,
   Globals,
   ObjCClass,
   ObjCEHType,
   ObjCIvar,
+  RPath,
+  Paths,
 };
 
 std::array<StringRef, 64> Keys = {
     "tapi_tbd_version",
     "files",
     "target_info",
     "targets",
     "target",
std::array<StringRef, 64> Keys = {
     "data",
     "text",
     "weaks",
     "thread_locals",
     "globals",
     "objc_classes",
     "objc_eh_types",
     "objc_ivars",
+    "rpaths",
+    "paths",
 };
 
 static llvm::SmallString<128> getErrorMsg(TBDKey Key) {
   return {"invalid ", Keys[Key], " section"};
 }
 
 class JSONStubError : public llvm::ErrorInfo<llvm::json::ParseError> {
 public:
Expected<TargetList> getTargetsSection(const Object *Section) {
   for (const Value &JSONTarget : *Targets) {
     const auto *Obj = JSONTarget.getAsObject();
     if (!Obj)
       return make_error<JSONStubError>(getErrorMsg(TBDKey::Target));
     auto TargetStr =
         getRequiredValue<StringRef>(TBDKey::Target, Obj, &Object::getString);
     if (!TargetStr)
       return make_error<JSONStubError>(getErrorMsg(TBDKey::Target));
+    auto VersionStr = getRequiredValue<StringRef>(TBDKey::Deployment, Obj,
+                                                  &Object::getString);
+    if (!VersionStr)
+      return make_error<JSONStubError>(getErrorMsg(TBDKey::Deployment));
+    VersionTuple Version;
+    if (Version.tryParse(*VersionStr))
+      return make_error<JSONStubError>(getErrorMsg(TBDKey::Deployment));
     auto TargetOrErr = Target::create(*TargetStr);
     if (!TargetOrErr)
       return make_error<JSONStubError>(getErrorMsg(TBDKey::Target));
+    TargetOrErr->MinDeployment = Version;
+
     IFTargets.push_back(*TargetOrErr);
-    // TODO: Implement Deployment Version.
   }
   return IFTargets;
 }
 
 Error collectSymbolsFromSegment(const Object *Segment, TargetsToSymbols &Result,
                                 SymbolFlags SectionFlag) {
   auto Err = collectFromArray(
       TBDKey::Globals, Segment, [&Result, &SectionFlag](StringRef Name) {
Err = collectFromArray(
         Result.back().second.emplace_back(Sym);
       });
   if (Err)
     return Err;
 
   SymbolFlags WeakFlag = SectionFlag | (SectionFlag == SymbolFlags::Undefined
                                             ? SymbolFlags::WeakReferenced
                                             : SymbolFlags::WeakDefined);
-  Err = collectFromArray(TBDKey::Weak, Segment,
-                         [&Result, WeakFlag](StringRef Name) {
-                           JSONSymbol Sym = {
-                               SymbolKind::GlobalSymbol,
-                               Name.str(),
-                               WeakFlag,
-                           };
-                           Result.back().second.emplace_back(Sym);
-                         });
+  Err = collectFromArray(
+      TBDKey::Weak, Segment, [&Result, WeakFlag](StringRef Name) {
+        JSONSymbol Sym = {SymbolKind::GlobalSymbol, Name.str(), WeakFlag};
   if (Err)
     return Err;
 
   Err = collectFromArray(
       TBDKey::ThreadLocal, Segment, [&Result, SectionFlag](StringRef Name) {
         JSONSymbol Sym = {SymbolKind::GlobalSymbol, Name.str(),
                           SymbolFlags::ThreadLocalValue | SectionFlag};
         Result.back().second.emplace_back(Sym);
for (auto Val : *Section) {
 
     auto *DataSection = Obj->getObject(Keys[TBDKey::Data]);
     auto *TextSection = Obj->getObject(Keys[TBDKey::Text]);
     // There should be at least one valid section.
     if (!DataSection && !TextSection)
       return make_error<JSONStubError>(getErrorMsg(Key));
 
     if (DataSection) {
-      auto Err = collectSymbolsFromSegment(DataSection, Result, SectionFlag);
+      auto Err = collectSymbolsFromSegment(DataSection, Result,
+                                           SectionFlag | SymbolFlags::Data);
       if (Err)
         return Err;
     }
     if (TextSection) {
-      auto Err = collectSymbolsFromSegment(TextSection, Result, SectionFlag);
+      auto Err = collectSymbolsFromSegment(TextSection, Result,
+                                           SectionFlag | SymbolFlags::Text);
       if (Err)
         return Err;
     }
   }
 
   return Result;
 }
 
Expected<IFPtr> parseToInterfaceFile(const Object *File) {
   AttrToTargets Clients = *ClientsOrErr;
 
   auto RLOrErr =
       getLibSection(File, TBDKey::ReexportLibs, TBDKey::Names, Targets);
   if (!RLOrErr)
     return RLOrErr.takeError();
   AttrToTargets ReexportLibs = std::move(*RLOrErr);
 
+  auto RPathsOrErr = getLibSection(File, TBDKey::RPath, TBDKey::Paths, Targets);
+  if (!RPathsOrErr)
+    return RPathsOrErr.takeError();
+  AttrToTargets RPaths = std::move(*RPathsOrErr);
+
   auto ExportsOrErr = getSymbolSection(File, TBDKey::Exports, Targets);
   if (!ExportsOrErr)
     return ExportsOrErr.takeError();
   TargetsToSymbols Exports = std::move(*ExportsOrErr);
 
   auto ReexportsOrErr = getSymbolSection(File, TBDKey::Reexports, Targets);
   if (!ReexportsOrErr)
     return ReexportsOrErr.takeError();
for (auto &[Lib, Targets] : Clients)
     for (auto Target : Targets)
       F->addAllowableClient(Lib, Target);
   for (auto &[Lib, Targets] : ReexportLibs)
     for (auto Target : Targets)
       F->addReexportedLibrary(Lib, Target);
   for (auto &[Lib, Targets] : Umbrellas)
     for (auto Target : Targets)
       F->addParentUmbrella(Target, Lib);
+  for (auto &[Path, Targets] : RPaths)
+    for (auto Target : Targets)
+      F->addRPath(Target, Path);
   for (auto &[Targets, Symbols] : Exports)
     for (auto &Sym : Symbols)
       F->addSymbol(Sym.Kind, Sym.Name, Targets, Sym.Flags);
   for (auto &[Targets, Symbols] : Reexports)
     for (auto &Sym : Symbols)
       F->addSymbol(Sym.Kind, Sym.Name, Targets, Sym.Flags);
   for (auto &[Targets, Symbols] : Undefineds)
     for (auto &Sym : Symbols)

llvm/unittests/TextAPI/TextStubHelpers.h

 #define TEXT_STUB_HELPERS_H
 
 namespace llvm {
 struct ExportedSymbol {
   MachO::SymbolKind Kind = MachO::SymbolKind::GlobalSymbol;
   std::string Name = {};
   bool Weak = false;
   bool ThreadLocalValue = false;
+  bool isData = false;
   MachO::TargetList Targets = {};
 };
 
 using ExportedSymbolSeq = std::vector<ExportedSymbol>;
-using UUIDs = std::vector<std::pair<llvm::MachO::Target, std::string>>;
+using TargetToAttr = std::vector<std::pair<llvm::MachO::Target, std::string>>;
 using TBDFile = std::unique_ptr<MachO::InterfaceFile>;
 using TBDReexportFile = std::shared_ptr<MachO::InterfaceFile>;
 
 inline bool operator<(const ExportedSymbol &LHS, const ExportedSymbol &RHS) {
   return std::tie(LHS.Kind, LHS.Name) < std::tie(RHS.Kind, RHS.Name);
 }
 
 inline bool operator==(const ExportedSymbol &LHS, const ExportedSymbol &RHS) {

llvm/unittests/TextAPI/TextStubV3Tests.cpp

TEST(TBDv3, ReadFile) {
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   auto Archs = AK_armv7 | AK_arm64;
   auto Platform = PLATFORM_IOS;
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
   EXPECT_EQ(Archs, File->getArchitectures());
-  UUIDs Uuids = {{Target(AK_armv7, PLATFORM_UNKNOWN),
+  TargetToAttr Uuids = {{Target(AK_armv7, PLATFORM_UNKNOWN),
                          "00000000-0000-0000-0000-000000000000"},
                         {Target(AK_arm64, PLATFORM_UNKNOWN),
                          "11111111-1111-1111-1111-111111111111"}};
   EXPECT_EQ(Uuids, File->uuids());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
   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(ObjCConstraintType::Retain_Release, File->getObjCConstraint());
TEST(TBDv3, ReadMultipleDocuments) {
   EXPECT_EQ(File->documents().size(), 1U);
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   auto Archs = AK_armv7 | AK_arm64;
   auto Platform = PLATFORM_IOS;
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
   EXPECT_EQ(Archs, File->getArchitectures());
-  UUIDs Uuids = {{Target(AK_armv7, PLATFORM_UNKNOWN),
+  TargetToAttr Uuids = {{Target(AK_armv7, PLATFORM_UNKNOWN),
                          "00000000-0000-0000-0000-000000000000"},
                         {Target(AK_arm64, PLATFORM_UNKNOWN),
                          "11111111-1111-1111-1111-111111111111"}};
   EXPECT_EQ(Uuids, File->uuids());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
   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(ObjCConstraintType::Retain_Release, File->getObjCConstraint());

llvm/unittests/TextAPI/TextStubV4Tests.cpp

TEST(TBDv4, ReadFile) {
   Platforms.insert(getPlatformFromName("macos"));
   Platforms.insert(getPlatformFromName("ios"));
   auto Archs = AK_i386 | AK_x86_64;
   TargetList Targets = {
       Target(AK_i386, PLATFORM_MACOS),
       Target(AK_x86_64, PLATFORM_MACOS),
       Target(AK_x86_64, PLATFORM_IOS),
   };
-  UUIDs uuids = {{Targets[0], "00000000-0000-0000-0000-000000000000"},
+  TargetToAttr uuids = {{Targets[0], "00000000-0000-0000-0000-000000000000"},
                         {Targets[1], "11111111-1111-1111-1111-111111111111"},
                         {Targets[2], "11111111-1111-1111-1111-111111111111"}};
   EXPECT_EQ(Archs, File->getArchitectures());
   EXPECT_EQ(uuids, File->uuids());
   EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
   for (auto Platform : File->getPlatforms())
     EXPECT_EQ(Platforms.count(Platform), 1U);
   EXPECT_EQ(std::string("Umbrella.framework/Umbrella"), File->getInstallName());
   EXPECT_EQ(PackedVersion(1, 2, 3), File->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 2, 0), File->getCompatibilityVersion());
TEST(TBDv4, ReadMultipleDocuments) {
   PlatformSet Platforms;
   Platforms.insert(PLATFORM_MACOS);
   Platforms.insert(PLATFORM_MACCATALYST);
   ArchitectureSet Archs = AK_i386 | AK_x86_64;
   TargetList Targets;
   for (auto &&Arch : Archs)
     for (auto &&Platform : Platforms)
       Targets.emplace_back(Target(Arch, Platform));
-  UUIDs Uuids = {
+  TargetToAttr Uuids = {
       {Targets[0], "00000000-0000-0000-0000-000000000000"},
       {Targets[1], "00000000-0000-0000-0000-000000000002"},
       {Targets[2], "11111111-1111-1111-1111-111111111111"},
       {Targets[3], "11111111-1111-1111-1111-111111111112"},
   };
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv4Inlines, "Test.tbd"));
static const char TBDv4File[] =
       "    symbols:         [ _symB ]\n"
       "...\n";
 
   InterfaceFile File;
   TargetList Targets = {
       Target(AK_i386, PLATFORM_MACOS),
       Target(AK_x86_64, PLATFORM_IOSSIMULATOR),
   };
-  UUIDs uuids = {{Targets[0], "00000000-0000-0000-0000-000000000000"},
+  TargetToAttr uuids = {{Targets[0], "00000000-0000-0000-0000-000000000000"},
                         {Targets[1], "11111111-1111-1111-1111-111111111111"}};
   File.setInstallName("Umbrella.framework/Umbrella");
   File.setFileType(FileType::TBD_V4);
   File.addTargets(Targets);
   File.addUUID(uuids[0].first, uuids[0].second);
   File.addUUID(uuids[1].first, uuids[1].second);
   File.setCurrentVersion(PackedVersion(1, 2, 3));
   File.setTwoLevelNamespace();
   File.setInstallAPI(true);
static const char TBDv4Inlines[] =
       "...\n";
 
   InterfaceFile File;
   PlatformType Platform = PLATFORM_MACCATALYST;
   TargetList Targets = {
       Target(AK_i386, Platform),
       Target(AK_x86_64, Platform),
   };
-  UUIDs Uuids = {{Targets[0], "00000000-0000-0000-0000-000000000002"},
+  TargetToAttr Uuids = {{Targets[0], "00000000-0000-0000-0000-000000000002"},
                         {Targets[1], "11111111-1111-1111-1111-111111111112"}};
   File.setInstallName("/System/Library/Frameworks/Umbrella.framework/Umbrella");
   File.setFileType(FileType::TBD_V4);
   File.addTargets(Targets);
   File.addUUID(Uuids[0].first, Uuids[0].second);
   File.addUUID(Uuids[1].first, Uuids[1].second);
   File.setCompatibilityVersion(PackedVersion(1, 0, 0));
   File.setCurrentVersion(PackedVersion(1, 0, 0));
   File.setTwoLevelNamespace();

llvm/unittests/TextAPI/TextStubV5Tests.cpp

]
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv5File, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V5, File->getFileType());
   EXPECT_EQ(std::string("/S/L/F/Foo.framework/Foo"), File->getInstallName());
 
   TargetList AllTargets = {
-      Target(AK_x86_64, PLATFORM_MACOS),
-      Target(AK_arm64, PLATFORM_MACOS),
-      Target(AK_arm64, PLATFORM_MACCATALYST),
+      Target(AK_x86_64, PLATFORM_MACOS, VersionTuple(10, 14)),
+      Target(AK_arm64, PLATFORM_MACOS, VersionTuple(10, 14)),
+      Target(AK_arm64, PLATFORM_MACCATALYST, VersionTuple(12, 1)),
   };
   EXPECT_EQ(mapToPlatformSet(AllTargets), File->getPlatforms());
   EXPECT_EQ(mapToArchitectureSet(AllTargets), File->getArchitectures());
 
   EXPECT_EQ(PackedVersion(1, 2, 0), File->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 1, 0), File->getCompatibilityVersion());
   EXPECT_TRUE(File->isApplicationExtensionSafe());
   EXPECT_FALSE(File->isTwoLevelNamespace());
 
   InterfaceFileRef ClientA("ClientA", AllTargets);
   InterfaceFileRef ClientB("ClientB", AllTargets);
   EXPECT_EQ(2U, File->allowableClients().size());
   EXPECT_EQ(ClientA, File->allowableClients().at(0));
   EXPECT_EQ(ClientB, File->allowableClients().at(1));
 
   InterfaceFileRef ReexportA("/u/l/l/libbar.dylib", AllTargets);
   InterfaceFileRef ReexportB("/u/l/l/libfoo.dylib", AllTargets);
   EXPECT_EQ(2U, File->reexportedLibraries().size());
   EXPECT_EQ(ReexportA, File->reexportedLibraries().at(0));
   EXPECT_EQ(ReexportB, File->reexportedLibraries().at(1));
 
-  std::vector<std::pair<Target, std::string>> Umbrellas = {
-      {Target(AK_x86_64, PLATFORM_MACOS), "System"},
+  TargetToAttr RPaths = {
+      {Target(AK_x86_64, PLATFORM_MACOS), "@executable_path/.../Frameworks"},
+  };
+  EXPECT_EQ(RPaths, File->rpaths());
+
+  TargetToAttr Umbrellas = {{Target(AK_x86_64, PLATFORM_MACOS), "System"},
                             {Target(AK_arm64, PLATFORM_MACOS), "System"},
                             {Target(AK_arm64, PLATFORM_MACCATALYST), "System"}};
   EXPECT_EQ(Umbrellas, File->umbrellas());
 
   ExportedSymbolSeq Exports, Reexports, Undefineds;
   for (const auto *Sym : File->symbols()) {
     TargetList SymTargets{Sym->targets().begin(), Sym->targets().end()};
     ExportedSymbol Temp =
-        ExportedSymbol{Sym->getKind(), std::string(Sym->getName()),
+        ExportedSymbol{Sym->getKind(),
+                       std::string(Sym->getName()),
                        Sym->isWeakDefined() || Sym->isWeakReferenced(),
-                       Sym->isThreadLocalValue(), SymTargets};
+                       Sym->isThreadLocalValue(),
+                       Sym->isData(),
+                       SymTargets};
     if (Sym->isUndefined())
       Undefineds.emplace_back(std::move(Temp));
     else
       Sym->isReexported() ? Reexports.emplace_back(std::move(Temp))
                           : Exports.emplace_back(std::move(Temp));
   }
   llvm::sort(Exports);
   llvm::sort(Reexports);
   llvm::sort(Undefineds);
 
   TargetList MacOSTargets = {Target(AK_x86_64, PLATFORM_MACOS),
                              Target(AK_arm64, PLATFORM_MACOS)};
 
   std::vector<ExportedSymbol> ExpectedExportedSymbols = {
-      {SymbolKind::GlobalSymbol, "_func", false, false, MacOSTargets},
+      {SymbolKind::GlobalSymbol, "_func", false, false, false, MacOSTargets},
       {SymbolKind::GlobalSymbol,
        "_funcFoo",
        false,
        false,
+       false,
        {Target(AK_x86_64, PLATFORM_MACOS)}},
-      {SymbolKind::GlobalSymbol, "_global", false, false, MacOSTargets},
+      {SymbolKind::GlobalSymbol, "_global", false, false, true, MacOSTargets},
       {SymbolKind::GlobalSymbol,
        "_globalVar",
        false,
        false,
+       true,
        {Target(AK_x86_64, PLATFORM_MACOS)}},
-      {SymbolKind::ObjectiveCClass, "ClassA", false, false, MacOSTargets},
+      {SymbolKind::ObjectiveCClass, "ClassA", false, false, true, MacOSTargets},
       {SymbolKind::ObjectiveCClass,
        "ClassData",
        false,
        false,
+       true,
        {Target(AK_x86_64, PLATFORM_MACOS)}},
       {SymbolKind::ObjectiveCClassEHType,
        "ClassA",
        false,
        false,
+       true,
        {Target(AK_x86_64, PLATFORM_MACOS)}},
       {SymbolKind::ObjectiveCClassEHType,
        "ClassB",
        false,
        false,
+       true,
        {Target(AK_x86_64, PLATFORM_MACOS)}},
       {SymbolKind::ObjectiveCInstanceVariable,
        "ClassA.ivar1",
        false,
        false,
+       true,
        {Target(AK_x86_64, PLATFORM_MACOS)}},
       {SymbolKind::ObjectiveCInstanceVariable,
        "ClassA.ivar2",
        false,
        false,
+       true,
        {Target(AK_x86_64, PLATFORM_MACOS)}},
       {SymbolKind::ObjectiveCInstanceVariable,
        "ClassC.ivar1",
        false,
        false,
+       true,
        {Target(AK_x86_64, PLATFORM_MACOS)}},
   };
   std::vector<ExportedSymbol> ExpectedReexportedSymbols = {
-      {SymbolKind::GlobalSymbol, "_funcA", false, false, MacOSTargets},
-      {SymbolKind::GlobalSymbol, "_globalRe", false, false, MacOSTargets},
-      {SymbolKind::ObjectiveCClass, "ClassRexport", false, false, MacOSTargets},
+      {SymbolKind::GlobalSymbol, "_funcA", false, false, false, MacOSTargets},
+      {SymbolKind::GlobalSymbol, "_globalRe", false, false, true, MacOSTargets},
+      {SymbolKind::ObjectiveCClass, "ClassRexport", false, false, true,
+       MacOSTargets},
   };
 
   std::vector<ExportedSymbol> ExpectedUndefinedSymbols = {
       {SymbolKind::GlobalSymbol,
        "_globalBind",
        false,
        false,
+       true,
        {Target(AK_x86_64, PLATFORM_MACOS)}},
       {SymbolKind::GlobalSymbol,
        "referenced_sym",
        true,
        false,
+       true,
        {Target(AK_x86_64, PLATFORM_MACOS)}},
   };
 
   EXPECT_EQ(ExpectedExportedSymbols.size(), Exports.size());
   EXPECT_EQ(ExpectedReexportedSymbols.size(), Reexports.size());
   EXPECT_EQ(ExpectedUndefinedSymbols.size(), Undefineds.size());
   EXPECT_TRUE(std::equal(Exports.begin(), Exports.end(),
                          std::begin(ExpectedExportedSymbols)));
]
   EXPECT_EQ(std::string("/usr/lib/libFoo.dylib"), File->getInstallName());
   EXPECT_TRUE(File->isApplicationExtensionSafe());
   EXPECT_TRUE(File->isTwoLevelNamespace());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
   EXPECT_EQ(8U, File->getSwiftABIVersion());
 
   TargetList AllTargets = {
-      Target(AK_x86_64, PLATFORM_MACOS),
-      Target(AK_arm64, PLATFORM_MACOS),
-      Target(AK_arm64, PLATFORM_MACCATALYST),
+      Target(AK_x86_64, PLATFORM_MACOS, VersionTuple(10, 14)),
+      Target(AK_arm64, PLATFORM_MACOS, VersionTuple(10, 14)),
+      Target(AK_arm64, PLATFORM_MACCATALYST, VersionTuple(12, 1)),
   };
   EXPECT_EQ(mapToPlatformSet(AllTargets), File->getPlatforms());
   EXPECT_EQ(mapToArchitectureSet(AllTargets), File->getArchitectures());
 
   InterfaceFileRef ReexportA("/u/l/l/libArmOnly.dylib",
                              {Target(AK_arm64, PLATFORM_MACCATALYST)});
   InterfaceFileRef ReexportB("/u/l/l/libbar.dylib",
                              {Target(AK_x86_64, PLATFORM_MACCATALYST)});
]})";
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V5, File->getFileType());
   EXPECT_EQ(std::string("/S/L/F/Foo.framework/Foo"), File->getInstallName());
   EXPECT_TRUE(File->isTwoLevelNamespace());
   EXPECT_TRUE(File->isApplicationExtensionSafe());
 
   TargetList Targets(File->targets().begin(), File->targets().end());
-  Target iOSTarget(AK_armv7, PLATFORM_IOS);
+  Target iOSTarget(AK_armv7, PLATFORM_IOS, VersionTuple(11, 0));
   EXPECT_EQ(TargetList{iOSTarget}, Targets);
   std::vector<const Symbol *> Symbols(File->symbols().begin(),
                                       File->symbols().end());
   EXPECT_EQ(0U, Symbols.size());
 
   InterfaceFileRef Reexport("/u/l/l/libfoo.dylib", {iOSTarget});
   EXPECT_EQ(1U, File->reexportedLibraries().size());
   EXPECT_EQ(Reexport, File->reexportedLibraries().at(0));
]})";
 
   ExportedSymbolSeq Exports;
   for (const auto *Sym : Document->symbols())
     Exports.emplace_back(
         ExportedSymbol{Sym->getKind(),
                        std::string(Sym->getName()),
                        Sym->isWeakDefined() || Sym->isWeakReferenced(),
                        Sym->isThreadLocalValue(),
+                       Sym->isData(),
                        {iOSTarget}});
 
   ExportedSymbolSeq ExpectedExports = {
-      {SymbolKind::GlobalSymbol, "_globalVar", false, true, {iOSTarget}},
-      {SymbolKind::ObjectiveCClass, "ClassData", false, false, {iOSTarget}},
-      {SymbolKind::ObjectiveCClassEHType, "ClassB", false, false, {iOSTarget}},
-      {SymbolKind::ObjectiveCClassEHType, "ClassA", false, false, {iOSTarget}},
-      {SymbolKind::GlobalSymbol, "_funcFoo", false, false, {iOSTarget}},
+      {SymbolKind::GlobalSymbol, "_globalVar", false, true, true, {iOSTarget}},
+      {SymbolKind::ObjectiveCClass,
+       "ClassData",
+       false,
+       false,
+       true,
+       {iOSTarget}},
+      {SymbolKind::ObjectiveCClassEHType,
+       "ClassB",
+       false,
+       false,
+       true,
+       {iOSTarget}},
+      {SymbolKind::ObjectiveCClassEHType,
+       "ClassA",
+       false,
+       false,
+       true,
+       {iOSTarget}},
+      {SymbolKind::GlobalSymbol, "_funcFoo", false, false, false, {iOSTarget}},
   };
 
   EXPECT_EQ(ExpectedExports.size(), Exports.size());
   EXPECT_TRUE(
       std::equal(Exports.begin(), Exports.end(), std::begin(ExpectedExports)));
 }
 
 } // end namespace TBDv5