[TextAPI] Introduce SymbolSet

[cishida]

Summary

SymbolSet is a structure that acts as a simple container class for exported symbols that
belong to a library interface. It allows tapi to decouple the globals
from the other library attributes. It's uniqued by symbol name and kind, which all contain their assigned target triples.

[ributzka]

llvm/lib/TextAPI/SymbolSet.cpp

29

Why add the corresponding Objective-C class here too?

[cishida]

llvm/lib/TextAPI/SymbolSet.cpp

29

hm, I'll try removing it. TAPI always expects these symbols to also have a corresponding class symbol. In theory, these should always exist so it doesn't need to be implicitly added. Though it's possible to export a ObjectiveCClassEHType without a ObjectiveCClass

[cishida]

Remove extra call to create objc class symbols

[cishida]

Fix bad docstrings

[zixuw]

llvm/include/llvm/TextAPI/InterfaceFile.h

346

nit: why do we need an std::optional instead of using the nullptr to indicate non-existence? And if the method returns the query element maybe we should give it another name than contains?

[zixuw]

llvm/include/llvm/TextAPI/Symbol.h

73–75

nit: I think lower_bound already uses operator< for comparison. Is this needed? Or maybe use std::less{}?

llvm/lib/TextAPI/Symbol.cpp

68–70

Could you explain more about this change? Is this change related to SymbolSet?

[cishida]

llvm/include/llvm/TextAPI/InterfaceFile.h

346

nullptr and std::nullopt evaluate differently in e.g. if (auto x = file->contains(sym)). I don't feel that strongly about supporting but it is used that way downstream.
I'll update the name though.

llvm/include/llvm/TextAPI/Symbol.h

73–75

This is just moved from InterfaceFile.cpp, I realized I forgot to delete that in this patch (will fix that) but I'd rather not update this code unless theres a strong reason to since its used in a lot of tapi data structure operations. Maybe worth revisiting though, if the code can be cleaned up.

llvm/lib/TextAPI/Symbol.cpp

68–70

I needed it to pass tests. This was an attempt to still check a TBD-v5 only attribute against older TBD file formats. Its not very useful or sound so I just removed it. The lambda should be removed too though.

[cishida]

llvm/lib/TextAPI/Symbol.cpp

68–70

NVM, I meant the removal is valid to be able to compare older files. Just trying to conditionalize it based off indirect assumptions isn't useful ATM. To be able to do this accurately I'd need to pass FileType down to this comparator.

[cishida]

Remove redundant code and rename contains method.

llvm/include/llvm/TextAPI/InterfaceFile.h

 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/TextAPI/ArchitectureSet.h"
 #include "llvm/TextAPI/PackedVersion.h"
 #include "llvm/TextAPI/Platform.h"
 #include "llvm/TextAPI/Symbol.h"
+#include "llvm/TextAPI/SymbolSet.h"
 #include "llvm/TextAPI/Target.h"
 
 namespace llvm {
 namespace MachO {
 
 /// Defines a list of Objective-C constraints.
 enum class ObjCConstraintType : unsigned {
   /// No constraint.

 
 private:
   std::string InstallName;
   TargetList Targets;
 };
 
 } // 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:
+  InterfaceFile(std::unique_ptr<SymbolSet> &&InputSymbols)
+      : SymbolsSet(std::move(InputSymbols)) {}
+
+  InterfaceFile() : SymbolsSet(std::make_unique<SymbolSet>()){};
   /// Set the path from which this file was generated (if applicable).
   ///
   /// \param Path_ The path to the source file.
   void setPath(StringRef Path_) { Path = std::string(Path_); }
 
   /// Get the path from which this file was generated (if applicable).
   ///
   /// \return The path to the source file or empty.
public:
 
   /// 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,
-            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; }
-  };
+  /// Get symbol if exists in file.
+  ///
+  /// \param Kind The kind of global symbol to record.
+  /// \param Name The name of the symbol.
+  std::optional<const Symbol *> getSymbol(SymbolKind Kind,
+                                          StringRef Name) const {
+    if (auto *Sym = SymbolsSet->findSymbol(Kind, Name))
+      return Sym;
+    return std::nullopt;
+  }
 
-  using const_symbol_range = iterator_range<const_symbol_iterator>;
+  /// Add a symbol to the symbols list or extend an existing one.
+  template <typename RangeT,
+            typename ElT = typename std::remove_reference<
+                decltype(*std::begin(std::declval<RangeT>()))>::type>
+  void addSymbol(SymbolKind Kind, StringRef Name, RangeT &&Targets,
+                 SymbolFlags Flags = SymbolFlags::None) {
+    SymbolsSet->addGlobal(Kind, Name, Flags, Targets);
+  }
 
-  using const_filtered_symbol_iterator =
-      filter_iterator<const_symbol_iterator,
-                      std::function<bool(const Symbol *)>>;
-  using const_filtered_symbol_range =
-      iterator_range<const_filtered_symbol_iterator>;
+  /// Add Symbol with multiple targets.
+  ///
+  /// \param Kind The kind of global symbol to record.
+  /// \param Name The name of the symbol.
+  /// \param Targets The list of targets the symbol is defined in.
+  /// \param Flags The properties the symbol holds.
+  void addSymbol(SymbolKind Kind, StringRef Name, TargetList &&Targets,
+                 SymbolFlags Flags = SymbolFlags::None) {
+    SymbolsSet->addGlobal(Kind, Name, Flags, Targets);
+  }
 
-  const_symbol_range symbols() const {
-    return {Symbols.begin(), Symbols.end()};
+  /// Add Symbol with single target.
+  ///
+  /// \param Kind The kind of global symbol to record.
+  /// \param Name The name of the symbol.
+  /// \param Target The target the symbol is defined in.
+  /// \param Flags The properties the symbol holds.
+  void addSymbol(SymbolKind Kind, StringRef Name, Target &Target,
+                 SymbolFlags Flags = SymbolFlags::None) {
+    SymbolsSet->addGlobal(Kind, Name, Flags, Target);
   }
 
-  size_t symbolsCount() const { return Symbols.size(); }
+  /// Get size of symbol set.
+  /// \return The number of symbols the file holds.
+  size_t symbolsCount() const { return SymbolsSet->size(); }
 
-  const_filtered_symbol_range exports() const {
-    std::function<bool(const Symbol *)> fn = [](const Symbol *Symbol) {
-      return !Symbol->isUndefined() && !Symbol->isReexported();
-    };
-    return make_filter_range(
-        make_range<const_symbol_iterator>({Symbols.begin()}, {Symbols.end()}),
-        fn);
-  }
+  using const_symbol_range = SymbolSet::const_symbol_range;
+  using const_filtered_symbol_range = SymbolSet::const_filtered_symbol_range;
 
+  const_symbol_range symbols() const { return SymbolsSet->symbols(); };
+  const_filtered_symbol_range exports() const { return SymbolsSet->exports(); };
   const_filtered_symbol_range reexports() const {
-    std::function<bool(const Symbol *)> fn = [](const Symbol *Symbol) {
-      return Symbol->isReexported();
-    };
-    return make_filter_range(
-        make_range<const_symbol_iterator>({Symbols.begin()}, {Symbols.end()}),
-        fn);
-  }
-
+    return SymbolsSet->reexports();
   const_filtered_symbol_range undefineds() const {
-    std::function<bool(const Symbol *)> fn = [](const Symbol *Symbol) {
-      return Symbol->isUndefined();
-    };
-    return make_filter_range(
-        make_range<const_symbol_iterator>({Symbols.begin()}, {Symbols.end()}),
-        fn);
-  }
+    return SymbolsSet->undefineds();
 
   /// The equality is determined by attributes that impact linking
   /// compatibilities. UUIDs, Path, & FileKind are irrelevant since these by
   /// itself should not impact linking.
   /// This is an expensive operation.
   bool operator==(const InterfaceFile &O) const;
 
   bool operator!=(const InterfaceFile &O) const { return !(*this == O); }
private:
   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;
+  std::unique_ptr<SymbolSet> SymbolsSet;
   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 *,
-                                   KeyInfoT, BucketT> &RHS) {
-  if (LHS.size() != RHS.size())
-    return false;
-  for (const auto &KV : LHS) {
-    auto I = RHS.find(KV.first);
-    if (I == RHS.end() || *I->second != *KV.second)
-      return false;
-  }
-  return true;
+// Keep containers that hold InterfaceFileRefs in sorted order and uniqued.
+template <typename C>
+typename C::iterator addEntry(C &Container, StringRef InstallName) {
+  auto I = partition_point(Container, [=](const InterfaceFileRef &O) {
+    return O.getInstallName() < InstallName;
+  });
+  if (I != Container.end() && I->getInstallName() == InstallName)
+    return I;
+
+  return Container.emplace(I, InstallName);
 }
 
 } // end namespace MachO.
 } // end namespace llvm.
 
 #endif // LLVM_TEXTAPI_INTERFACEFILE_H

llvm/include/llvm/TextAPI/Symbol.h

 
 constexpr StringLiteral ObjC1ClassNamePrefix = ".objc_class_name_";
 constexpr StringLiteral ObjC2ClassNamePrefix = "_OBJC_CLASS_$_";
 constexpr StringLiteral ObjC2MetaClassNamePrefix = "_OBJC_METACLASS_$_";
 constexpr StringLiteral ObjC2EHTypePrefix = "_OBJC_EHTYPE_$_";
 constexpr StringLiteral ObjC2IVarPrefix = "_OBJC_IVAR_$_";
 
 using TargetList = SmallVector<Target, 5>;
+
+// Keep containers that hold Targets in sorted order and uniqued.
+template <typename C>
+typename C::iterator addEntry(C &Container, const Target &Targ) {
+  auto Iter =
+      lower_bound(Container, Targ, [](const Target &LHS, const Target &RHS) {
+        return LHS < RHS;
+      });
+  if ((Iter != std::end(Container)) && !(Targ < *Iter))
+    return Iter;
+
+  return Container.insert(Iter, Targ);
+}
+
 class Symbol {
 public:
   Symbol(SymbolKind Kind, StringRef Name, TargetList Targets, SymbolFlags Flags)
       : Name(Name), Targets(std::move(Targets)), Kind(Kind), Flags(Flags) {}
 
-  void addTarget(Target target) { Targets.emplace_back(target); }
+  void addTarget(Target InputTarget) { addEntry(Targets, InputTarget); }
   SymbolKind getKind() const { return Kind; }
   StringRef getName() const { return Name; }
   ArchitectureSet getArchitectures() const {
     return mapToArchitectureSet(Targets);
   }
   SymbolFlags getFlags() const { return Flags; }
 
   bool isWeakDefined() const {

llvm/include/llvm/TextAPI/SymbolSet.h

+//===- llvm/TextAPI/SymbolSet.h - TAPI Symbol Set --------------*- 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_SYMBOLSET_H
+#define LLVM_TEXTAPI_SYMBOLSET_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/TextAPI/Architecture.h"
+#include "llvm/TextAPI/ArchitectureSet.h"
+#include "llvm/TextAPI/Symbol.h"
+#include <stddef.h>
+
+namespace llvm {
+
+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);
+  }
+};
+
+template <typename DerivedT, typename KeyInfoT, typename BucketT>
+bool operator==(const DenseMapBase<DerivedT, SymbolsMapKey, MachO::Symbol *,
+                                   KeyInfoT, BucketT> &LHS,
+                const DenseMapBase<DerivedT, SymbolsMapKey, MachO::Symbol *,
+                                   KeyInfoT, BucketT> &RHS) {
+  if (LHS.size() != RHS.size())
+    return false;
+  for (const auto &KV : LHS) {
+    auto I = RHS.find(KV.first);
+    if (I == RHS.end() || *I->second != *KV.second)
+      return false;
+  }
+  return true;
+}
+
+template <typename DerivedT, typename KeyInfoT, typename BucketT>
+bool operator!=(const DenseMapBase<DerivedT, SymbolsMapKey, MachO::Symbol *,
+                                   KeyInfoT, BucketT> &LHS,
+                const DenseMapBase<DerivedT, SymbolsMapKey, MachO::Symbol *,
+                                   KeyInfoT, BucketT> &RHS) {
+  return !(LHS == RHS);
+}
+
+namespace MachO {
+
+class SymbolSet {
+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());
+  }
+
+  using SymbolsMapType = llvm::DenseMap<SymbolsMapKey, Symbol *>;
+  SymbolsMapType Symbols;
+
+  Symbol *addGlobalImpl(SymbolKind, StringRef Name, SymbolFlags Flags);
+
+public:
+  SymbolSet() = default;
+  Symbol *addGlobal(SymbolKind Kind, StringRef Name, SymbolFlags Flags,
+                    const Target &Targ);
+  size_t size() const { return Symbols.size(); }
+
+  template <typename RangeT,
+            typename ElT = typename std::remove_reference<
+                decltype(*std::begin(std::declval<RangeT>()))>::type>
+  Symbol *addGlobal(SymbolKind Kind, StringRef Name, SymbolFlags Flags,
+                    RangeT &&Targets) {
+    auto *Global = addGlobalImpl(Kind, Name, Flags);
+    for (const auto &Targ : Targets)
+      Global->addTarget(Targ);
+    if (Kind == SymbolKind::ObjectiveCClassEHType)
+      addGlobal(SymbolKind::ObjectiveCClass, Name, Flags, Targets);
+    return Global;
+  }
+
+  const Symbol *findSymbol(SymbolKind Kind, StringRef Name) const;
+
+  struct const_symbol_iterator
+      : public iterator_adaptor_base<
+            const_symbol_iterator, SymbolsMapType::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>;
+
+  using const_filtered_symbol_iterator =
+      filter_iterator<const_symbol_iterator,
+                      std::function<bool(const Symbol *)>>;
+  using const_filtered_symbol_range =
+      iterator_range<const_filtered_symbol_iterator>;
+
+  // Range that contains all symbols.
+  const_symbol_range symbols() const {
+    return {Symbols.begin(), Symbols.end()};
+  }
+
+  // Range that contains all defined and exported symbols.
+  const_filtered_symbol_range exports() const {
+    std::function<bool(const Symbol *)> fn = [](const Symbol *Symbol) {
+      return !Symbol->isUndefined() && !Symbol->isReexported();
+    };
+    return make_filter_range(
+        make_range<const_symbol_iterator>({Symbols.begin()}, {Symbols.end()}),
+        fn);
+  }
+
+  // Range that contains all reexported symbols.
+  const_filtered_symbol_range reexports() const {
+    std::function<bool(const Symbol *)> fn = [](const Symbol *Symbol) {
+      return Symbol->isReexported();
+    };
+    return make_filter_range(
+        make_range<const_symbol_iterator>({Symbols.begin()}, {Symbols.end()}),
+        fn);
+  }
+
+  // Range that contains all undefined and exported symbols.
+  const_filtered_symbol_range undefineds() const {
+    std::function<bool(const Symbol *)> fn = [](const Symbol *Symbol) {
+      return Symbol->isUndefined();
+    };
+    return make_filter_range(
+        make_range<const_symbol_iterator>({Symbols.begin()}, {Symbols.end()}),
+        fn);
+  }
+
+  bool operator==(const SymbolSet &O) const;
+
+  bool operator!=(const SymbolSet &O) const { return !(Symbols == O.Symbols); }
+
+  void *allocate(size_t Size, unsigned Align = 8) {
+    return Allocator.Allocate(Size, Align);
+  }
+};
+
+} // namespace MachO
+} // namespace llvm
+#endif // LLVM_TEXTAPI_SYMBOLSET_H

llvm/lib/TextAPI/CMakeLists.txt

 add_llvm_component_library(LLVMTextAPI
   Architecture.cpp
   ArchitectureSet.cpp
   InterfaceFile.cpp
   TextStubV5.cpp
   PackedVersion.cpp
   Platform.cpp
   Symbol.cpp
+  SymbolSet.cpp
   Target.cpp
   TextStub.cpp
   TextStubCommon.cpp
 
   ADDITIONAL_HEADER_DIRS
   "${LLVM_MAIN_INCLUDE_DIR}/llvm/TextAPI"
 
   LINK_COMPONENTS
   Support
   BinaryFormat
   TargetParser
 )

llvm/lib/TextAPI/InterfaceFile.cpp

 
 #include "llvm/TextAPI/InterfaceFile.h"
 #include <iomanip>
 #include <sstream>
 
 using namespace llvm;
 using namespace llvm::MachO;
 
-namespace {
-template <typename C>
-typename C::iterator addEntry(C &Container, StringRef InstallName) {
-  auto I = partition_point(Container, [=](const InterfaceFileRef &O) {
-    return O.getInstallName() < InstallName;
-  });
-  if (I != Container.end() && I->getInstallName() == InstallName)
-    return I;
-
-  return Container.emplace(I, InstallName);
-}
-
-template <typename C>
-typename C::iterator addEntry(C &Container, const Target &Target_) {
-  auto Iter =
-      lower_bound(Container, Target_, [](const Target &LHS, const Target &RHS) {
-        return LHS < RHS;
-      });
-  if ((Iter != std::end(Container)) && !(Target_ < *Iter))
-    return Iter;
-
-  return Container.insert(Iter, Target_);
-}
-} // end namespace
-
 void InterfaceFileRef::addTarget(const Target &Target) {
   addEntry(Targets, Target);
 }
 
 void InterfaceFile::addAllowableClient(StringRef InstallName,
                                        const Target &Target) {
   auto Client = addEntry(AllowableClients, InstallName);
   Client->addTarget(Target);

 InterfaceFile::const_filtered_target_range
 InterfaceFile::targets(ArchitectureSet Archs) const {
   std::function<bool(const Target &)> fn = [Archs](const Target &Target_) {
     return Archs.has(Target_.Arch);
   };
   return make_filter_range(Targets, fn);
 }
 
-void InterfaceFile::addSymbol(SymbolKind Kind, StringRef Name,
-                              const TargetList &Targets, SymbolFlags Flags) {
-  Name = copyString(Name);
-  auto result = Symbols.try_emplace(SymbolsMapKey{Kind, Name}, nullptr);
-  if (result.second)
-    result.first->second = new (Allocator) Symbol{Kind, Name, Targets, Flags};
-  else
-    for (const auto &Target : Targets)
-      result.first->second->addTarget(Target);
-}
-
 void InterfaceFile::addDocument(std::shared_ptr<InterfaceFile> &&Document) {
   auto Pos = llvm::lower_bound(Documents, Document,
                                [](const std::shared_ptr<InterfaceFile> &LHS,
                                   const std::shared_ptr<InterfaceFile> &RHS) {
                                  return LHS->InstallName < RHS->InstallName;
                                });
   Document->Parent = this;
   Documents.insert(Pos, Document);
bool InterfaceFile::operator==(const InterfaceFile &O) const {
   if (IsInstallAPI != O.IsInstallAPI)
     return false;
   if (ParentUmbrellas != O.ParentUmbrellas)
     return false;
   if (AllowableClients != O.AllowableClients)
     return false;
   if (ReexportedLibraries != O.ReexportedLibraries)
     return false;
-  if (Symbols != O.Symbols)
+  if (*SymbolsSet != *O.SymbolsSet)
     return false;
   // Don't compare run search paths for older filetypes that cannot express
   // them.
   if (!(isYAMLTextStub(FileKind)) && !(isYAMLTextStub(O.FileKind))) {
     if (RPaths != O.RPaths)
       return false;
     if (mapToPlatformVersionSet(Targets) != mapToPlatformVersionSet(O.Targets))
       return false;

llvm/lib/TextAPI/Symbol.cpp

bool Symbol::operator==(const Symbol &O) const {
   auto RemoveFlag = [](const Symbol &Sym, SymbolFlags &Flag) {
     if (Sym.isData())
       Flag &= ~SymbolFlags::Data;
     if (Sym.isText())
       Flag &= ~SymbolFlags::Text;
   };
   SymbolFlags LHSFlags = Flags;
   SymbolFlags RHSFlags = O.Flags;
-  if ((!O.isData() && !O.isText()) || (!isData() && !isText())) {
-    RemoveFlag(*this, LHSFlags);
-    RemoveFlag(O, RHSFlags);
-  }
+  // Ignore Text and Data for now.
   return std::tie(Name, Kind, Targets, LHSFlags) ==
          std::tie(O.Name, O.Kind, O.Targets, RHSFlags);
 }
 
 } // end namespace MachO.
 } // end namespace llvm.

llvm/lib/TextAPI/SymbolSet.cpp

+//===- lib/TextAPI/SymbolSet.cpp - TAPI Symbol Set ------------*- C++-*----===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/TextAPI/SymbolSet.h"
+
+using namespace llvm;
+using namespace llvm::MachO;
+
+Symbol *SymbolSet::addGlobalImpl(SymbolKind Kind, StringRef Name,
+                                 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, TargetList(), Flags};
+  return Result.first->second;
+}
+
+Symbol *SymbolSet::addGlobal(SymbolKind Kind, StringRef Name, SymbolFlags Flags,
+                             const Target &Targ) {
+  auto *Sym = addGlobalImpl(Kind, Name, Flags);
+  Sym->addTarget(Targ);
+  return Sym;
+}
+
+const Symbol *SymbolSet::findSymbol(SymbolKind Kind, StringRef Name) const {
+  auto It = Symbols.find({Kind, Name});
+  if (It != Symbols.end())
+    return It->second;
+  return nullptr;
+}

llvm/unittests/TextAPI/TextStubV5Tests.cpp

"exported_symbols": [
       "targets": [
           "x86_64-macos"
       ],
       "data": {
           "global": [
               "_globalVar"
           ],
           "objc_class": [
+              "ClassA",
+              "ClassB",
               "ClassData"
           ],
           "objc_eh_type": [
               "ClassA",
               "ClassB"
           ],
           "objc_ivar": [
               "ClassA.ivar1",
std::vector<ExportedSymbol> ExpectedExportedSymbols = {
        {Target(AK_x86_64, PLATFORM_MACOS)}},
       {SymbolKind::GlobalSymbol, "_global", false, false, true, MacOSTargets},
       {SymbolKind::GlobalSymbol,
        "_globalVar",
        false,
        false,
        true,
        {Target(AK_x86_64, PLATFORM_MACOS)}},
-      {SymbolKind::ObjectiveCClass, "ClassA", false, false, true, MacOSTargets},
+      {SymbolKind::ObjectiveCClass,
+       "ClassA",
+       false,
+       false,
+       true,
+       {Target(AK_x86_64, PLATFORM_MACOS)}},
+      {SymbolKind::ObjectiveCClass,
+       "ClassB",
+       false,
+       false,
+       true,
+       {Target(AK_x86_64, PLATFORM_MACOS)}},
       {SymbolKind::ObjectiveCClass,
        "ClassData",
        false,
        false,
        true,
        {Target(AK_x86_64, PLATFORM_MACOS)}},
       {SymbolKind::ObjectiveCClassEHType,
        "ClassA",
"libraries": []
   EXPECT_EQ(ExpectedReexportedSymbols.size(), Reexports.size());
   EXPECT_EQ(ExpectedUndefinedSymbols.size(), Undefineds.size());
   EXPECT_TRUE(std::equal(Exports.begin(), Exports.end(),
                          std::begin(ExpectedExportedSymbols)));
   EXPECT_TRUE(std::equal(Reexports.begin(), Reexports.end(),
                          std::begin(ExpectedReexportedSymbols)));
   EXPECT_TRUE(std::equal(Undefineds.begin(), Undefineds.end(),
                          std::begin(ExpectedUndefinedSymbols)));
+
+  EXPECT_TRUE(
+      File->getSymbol(SymbolKind::GlobalSymbol, "_globalBind").has_value());
 }
 
 TEST(TBDv5, ReadMultipleTargets) {
   static const char TBDv5File[] = R"({ 
 "tapi_tbd_version": 5,
 "main_library":  {
   "target_info": [
       {
"libraries": [
     ],
     "flags":[ 
       { "attributes": ["not_app_extension_safe"] }
     ], 
     "exported_symbols": [
       {
         "data": {
           "thread_local": [ "_globalVar" ],
-          "objc_class": [ "ClassData" ], 
+          "objc_class": [ "ClassData", "ClassA", "ClassB"], 
           "objc_eh_type": [ "ClassA", "ClassB" ]
         },
         "text": {
           "global": [ "_funcFoo" ]
         }
       }
     ]
   }
Exports.emplace_back(
                        Sym->isThreadLocalValue(),
                        Sym->isData(),
                        {iOSTarget}});
 
   llvm::sort(Exports);
   ExportedSymbolSeq ExpectedExports = {
       {SymbolKind::GlobalSymbol, "_funcFoo", false, false, false, {iOSTarget}},
       {SymbolKind::GlobalSymbol, "_globalVar", false, true, true, {iOSTarget}},
+      {SymbolKind::ObjectiveCClass, "ClassA", false, false, true, {iOSTarget}},
+      {SymbolKind::ObjectiveCClass, "ClassB", false, false, true, {iOSTarget}},
       {SymbolKind::ObjectiveCClass,
        "ClassData",
        false,
        false,
        true,
        {iOSTarget}},
       {SymbolKind::ObjectiveCClassEHType,
        "ClassA",
"exported_symbols": [
       "targets": [
           "x86_64-macos"
       ],
       "data": {
           "global": [
               "_globalVar"
           ],
           "objc_class": [
+              "ClassA",
+              "ClassB",
               "ClassData"
           ],
           "objc_eh_type": [
               "ClassA",
               "ClassB"
           ],
           "objc_ivar": [
               "ClassA.ivar1",