[TextAPI] Rename SymbolKind to EncodeKind (#79622)

A distinction that doesn't _usually_ matter is that the
MachO::SymbolKind is really a mapping of entries in TBD files not
symbols. To better understand this, rename the enum so it represents an
encoding mapped to TBDs as opposed to symbols alone.

For example, it can be a bit confusing that "GlobalSymbol" is a enum
value when all of those values can represent a GlobalSymbol.

Author: cyndyishida

lld/MachO/InputFiles.cpp

@@ -1904,30 +1904,30 @@ DylibFile::DylibFile(const InterfaceFile &interface, DylibFile *umbrella,
       continue;
 
     switch (symbol->getKind()) {
-    case SymbolKind::GlobalSymbol:
-    case SymbolKind::ObjectiveCClass:
-    case SymbolKind::ObjectiveCClassEHType:
-    case SymbolKind::ObjectiveCInstanceVariable:
+    case EncodeKind::GlobalSymbol:
+    case EncodeKind::ObjectiveCClass:
+    case EncodeKind::ObjectiveCClassEHType:
+    case EncodeKind::ObjectiveCInstanceVariable:
       normalSymbols.push_back(symbol);
     }
   }
 
   // TODO(compnerd) filter out symbols based on the target platform
   for (const auto *symbol : normalSymbols) {
     switch (symbol->getKind()) {
-    case SymbolKind::GlobalSymbol:
+    case EncodeKind::GlobalSymbol:
       addSymbol(*symbol, symbol->getName());
       break;
-    case SymbolKind::ObjectiveCClass:
+    case EncodeKind::ObjectiveCClass:
       // XXX ld64 only creates these symbols when -ObjC is passed in. We may
       // want to emulate that.
       addSymbol(*symbol, objc::klass + symbol->getName());
       addSymbol(*symbol, objc::metaclass + symbol->getName());
       break;
-    case SymbolKind::ObjectiveCClassEHType:
+    case EncodeKind::ObjectiveCClassEHType:
       addSymbol(*symbol, objc::ehtype + symbol->getName());
       break;
-    case SymbolKind::ObjectiveCInstanceVariable:
+    case EncodeKind::ObjectiveCInstanceVariable:
       addSymbol(*symbol, objc::ivar + symbol->getName());
       break;
     }

llvm/include/llvm/TextAPI/InterfaceFile.h

@@ -351,7 +351,7 @@ class InterfaceFile {
   ///
   /// \param Kind The kind of global symbol to record.
   /// \param Name The name of the symbol.
-  std::optional<const Symbol *> getSymbol(SymbolKind Kind,
+  std::optional<const Symbol *> getSymbol(EncodeKind Kind,
                                           StringRef Name) const {
     if (auto *Sym = SymbolsSet->findSymbol(Kind, Name))
       return Sym;
@@ -361,7 +361,7 @@ class InterfaceFile {
   /// Add a symbol to the symbols list or extend an existing one.
   template <typename RangeT, typename ElT = std::remove_reference_t<
                                  decltype(*std::begin(std::declval<RangeT>()))>>
-  void addSymbol(SymbolKind Kind, StringRef Name, RangeT &&Targets,
+  void addSymbol(EncodeKind Kind, StringRef Name, RangeT &&Targets,
                  SymbolFlags Flags = SymbolFlags::None) {
     SymbolsSet->addGlobal(Kind, Name, Flags, Targets);
   }
@@ -372,7 +372,7 @@ class InterfaceFile {
   /// \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,
+  void addSymbol(EncodeKind Kind, StringRef Name, TargetList &&Targets,
                  SymbolFlags Flags = SymbolFlags::None) {
     SymbolsSet->addGlobal(Kind, Name, Flags, Targets);
   }
@@ -383,7 +383,7 @@ class InterfaceFile {
   /// \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,
+  void addSymbol(EncodeKind Kind, StringRef Name, Target &Target,
                  SymbolFlags Flags = SymbolFlags::None) {
     SymbolsSet->addGlobal(Kind, Name, Flags, Target);
   }

llvm/include/llvm/TextAPI/Symbol.h

@@ -51,7 +51,8 @@ enum class SymbolFlags : uint8_t {
 
 // clang-format on
 
-enum class SymbolKind : uint8_t {
+/// Mapping of entry types in TextStubs.
+enum class EncodeKind : uint8_t {
   GlobalSymbol,
   ObjectiveCClass,
   ObjectiveCClassEHType,
@@ -81,11 +82,11 @@ typename C::iterator addEntry(C &Container, const Target &Targ) {
 
 class Symbol {
 public:
-  Symbol(SymbolKind Kind, StringRef Name, TargetList Targets, SymbolFlags Flags)
+  Symbol(EncodeKind Kind, StringRef Name, TargetList Targets, SymbolFlags Flags)
       : Name(Name), Targets(std::move(Targets)), Kind(Kind), Flags(Flags) {}
 
   void addTarget(Target InputTarget) { addEntry(Targets, InputTarget); }
-  SymbolKind getKind() const { return Kind; }
+  EncodeKind getKind() const { return Kind; }
   StringRef getName() const { return Name; }
   ArchitectureSet getArchitectures() const {
     return mapToArchitectureSet(Targets);
@@ -156,21 +157,21 @@ class Symbol {
 private:
   StringRef Name;
   TargetList Targets;
-  SymbolKind Kind;
+  EncodeKind Kind;
   SymbolFlags Flags;
 };
 
 /// Lightweight struct for passing around symbol information.
 struct SimpleSymbol {
   StringRef Name;
-  SymbolKind Kind;
+  EncodeKind Kind;
 
   bool operator<(const SimpleSymbol &O) const {
     return std::tie(Name, Kind) < std::tie(O.Name, O.Kind);
   }
 };
 
-/// Determine SymbolKind from Flags and parsing Name.
+/// Determine EncodeKind from Flags and parsing Name.
 ///
 /// \param Name The name of symbol.
 /// \param Flags The flags pre-determined for the symbol.

llvm/include/llvm/TextAPI/SymbolSet.h

@@ -23,19 +23,19 @@
 namespace llvm {
 
 struct SymbolsMapKey {
-  MachO::SymbolKind Kind;
+  MachO::EncodeKind Kind;
   StringRef Name;
 
-  SymbolsMapKey(MachO::SymbolKind Kind, StringRef Name)
+  SymbolsMapKey(MachO::EncodeKind Kind, StringRef Name)
       : Kind(Kind), Name(Name) {}
 };
 template <> struct DenseMapInfo<SymbolsMapKey> {
   static inline SymbolsMapKey getEmptyKey() {
-    return SymbolsMapKey(MachO::SymbolKind::GlobalSymbol, StringRef{});
+    return SymbolsMapKey(MachO::EncodeKind::GlobalSymbol, StringRef{});
   }
 
   static inline SymbolsMapKey getTombstoneKey() {
-    return SymbolsMapKey(MachO::SymbolKind::ObjectiveCInstanceVariable,
+    return SymbolsMapKey(MachO::EncodeKind::ObjectiveCInstanceVariable,
                          StringRef{});
   }
 
@@ -87,27 +87,27 @@ class SymbolSet {
   using SymbolsMapType = llvm::DenseMap<SymbolsMapKey, Symbol *>;
   SymbolsMapType Symbols;
 
-  Symbol *addGlobalImpl(SymbolKind, StringRef Name, SymbolFlags Flags);
+  Symbol *addGlobalImpl(EncodeKind, StringRef Name, SymbolFlags Flags);
 
 public:
   SymbolSet() = default;
-  Symbol *addGlobal(SymbolKind Kind, StringRef Name, SymbolFlags Flags,
+  Symbol *addGlobal(EncodeKind Kind, StringRef Name, SymbolFlags Flags,
                     const Target &Targ);
   size_t size() const { return Symbols.size(); }
 
   template <typename RangeT, typename ElT = std::remove_reference_t<
                                  decltype(*std::begin(std::declval<RangeT>()))>>
-  Symbol *addGlobal(SymbolKind Kind, StringRef Name, SymbolFlags Flags,
+  Symbol *addGlobal(EncodeKind 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);
+    if (Kind == EncodeKind::ObjectiveCClassEHType)
+      addGlobal(EncodeKind::ObjectiveCClass, Name, Flags, Targets);
     return Global;
   }
 
-  const Symbol *findSymbol(SymbolKind Kind, StringRef Name) const;
+  const Symbol *findSymbol(EncodeKind Kind, StringRef Name) const;
 
   struct const_symbol_iterator
       : public iterator_adaptor_base<

llvm/lib/Object/TapiFile.cpp

@@ -56,11 +56,11 @@ TapiFile::TapiFile(MemoryBufferRef Source, const InterfaceFile &Interface,
       continue;
 
     switch (Symbol->getKind()) {
-    case SymbolKind::GlobalSymbol:
+    case EncodeKind::GlobalSymbol:
       Symbols.emplace_back(StringRef(), Symbol->getName(), getFlags(Symbol),
                            ::getType(Symbol));
       break;
-    case SymbolKind::ObjectiveCClass:
+    case EncodeKind::ObjectiveCClass:
       if (Interface.getPlatforms().count(PLATFORM_MACOS) && Arch == AK_i386) {
         Symbols.emplace_back(ObjC1ClassNamePrefix, Symbol->getName(),
                              getFlags(Symbol), ::getType(Symbol));
@@ -71,11 +71,11 @@ TapiFile::TapiFile(MemoryBufferRef Source, const InterfaceFile &Interface,
                              getFlags(Symbol), ::getType(Symbol));
       }
       break;
-    case SymbolKind::ObjectiveCClassEHType:
+    case EncodeKind::ObjectiveCClassEHType:
       Symbols.emplace_back(ObjC2EHTypePrefix, Symbol->getName(),
                            getFlags(Symbol), ::getType(Symbol));
       break;
-    case SymbolKind::ObjectiveCInstanceVariable:
+    case EncodeKind::ObjectiveCInstanceVariable:
       Symbols.emplace_back(ObjC2IVarPrefix, Symbol->getName(), getFlags(Symbol),
                            ::getType(Symbol));
       break;

llvm/lib/TextAPI/RecordVisitor.cpp

@@ -41,17 +41,17 @@ void SymbolConverter::addIVars(const ArrayRef<ObjCIVarRecord *> IVars,
       continue;
     std::string Name =
         ObjCIVarRecord::createScopedName(ContainerName, IV->getName());
-    Symbols->addGlobal(SymbolKind::ObjectiveCInstanceVariable, Name,
+    Symbols->addGlobal(EncodeKind::ObjectiveCInstanceVariable, Name,
                        IV->getFlags(), Targ);
   }
 }
 
 void SymbolConverter::visitObjCInterface(const ObjCInterfaceRecord &ObjCR) {
   if (!shouldSkipRecord(ObjCR, RecordUndefs)) {
-    Symbols->addGlobal(SymbolKind::ObjectiveCClass, ObjCR.getName(),
+    Symbols->addGlobal(EncodeKind::ObjectiveCClass, ObjCR.getName(),
                        ObjCR.getFlags(), Targ);
     if (ObjCR.hasExceptionAttribute())
-      Symbols->addGlobal(SymbolKind::ObjectiveCClassEHType, ObjCR.getName(),
+      Symbols->addGlobal(EncodeKind::ObjectiveCClassEHType, ObjCR.getName(),
                          ObjCR.getFlags(), Targ);
   }
 

llvm/lib/TextAPI/RecordsSlice.cpp

@@ -25,13 +25,13 @@ Record *RecordsSlice::addRecord(StringRef Name, SymbolFlags Flags,
   auto [APIName, SymKind] = parseSymbol(Name, Flags);
   Name = APIName;
   switch (SymKind) {
-  case SymbolKind::GlobalSymbol:
+  case EncodeKind::GlobalSymbol:
     return addGlobal(Name, Linkage, GV, Flags);
-  case SymbolKind::ObjectiveCClass:
+  case EncodeKind::ObjectiveCClass:
     return addObjCInterface(Name, Linkage);
-  case SymbolKind::ObjectiveCClassEHType:
+  case EncodeKind::ObjectiveCClassEHType:
     return addObjCInterface(Name, Linkage, /*HasEHType=*/true);
-  case SymbolKind::ObjectiveCInstanceVariable: {
+  case EncodeKind::ObjectiveCInstanceVariable: {
     auto [Super, IVar] = Name.split('.');
     // Attempt to find super class.
     ObjCContainerRecord *Container = findContainer(/*isIVar=*/false, Super);

llvm/lib/TextAPI/Symbol.cpp

@@ -28,16 +28,16 @@ LLVM_DUMP_METHOD void Symbol::dump(raw_ostream &OS) const {
   if (isThreadLocalValue())
     Result += "(tlv) ";
   switch (Kind) {
-  case SymbolKind::GlobalSymbol:
+  case EncodeKind::GlobalSymbol:
     Result += Name.str();
     break;
-  case SymbolKind::ObjectiveCClass:
+  case EncodeKind::ObjectiveCClass:
     Result += "(ObjC Class) " + Name.str();
     break;
-  case SymbolKind::ObjectiveCClassEHType:
+  case EncodeKind::ObjectiveCClassEHType:
     Result += "(ObjC Class EH) " + Name.str();
     break;
-  case SymbolKind::ObjectiveCInstanceVariable:
+  case EncodeKind::ObjectiveCInstanceVariable:
     Result += "(ObjC IVar) " + Name.str();
     break;
   }
@@ -75,27 +75,27 @@ bool Symbol::operator==(const Symbol &O) const {
 SimpleSymbol parseSymbol(StringRef SymName, const SymbolFlags Flags) {
   if (SymName.starts_with(ObjC1ClassNamePrefix))
     return {SymName.drop_front(ObjC1ClassNamePrefix.size()),
-            SymbolKind::ObjectiveCClass};
+            EncodeKind::ObjectiveCClass};
   if (SymName.starts_with(ObjC2ClassNamePrefix))
     return {SymName.drop_front(ObjC2ClassNamePrefix.size()),
-            SymbolKind::ObjectiveCClass};
+            EncodeKind::ObjectiveCClass};
   if (SymName.starts_with(ObjC2MetaClassNamePrefix))
     return {SymName.drop_front(ObjC2MetaClassNamePrefix.size()),
-            SymbolKind::ObjectiveCClass};
+            EncodeKind::ObjectiveCClass};
   if (SymName.starts_with(ObjC2EHTypePrefix)) {
     // When classes without ehtype are used in try/catch blocks
     // a weak-defined symbol is exported. In those cases, treat these as a
     // global instead.
     if ((Flags & SymbolFlags::WeakDefined) == SymbolFlags::WeakDefined)
-      return {SymName, SymbolKind::GlobalSymbol};
+      return {SymName, EncodeKind::GlobalSymbol};
     return {SymName.drop_front(ObjC2EHTypePrefix.size()),
-            SymbolKind::ObjectiveCClassEHType};
+            EncodeKind::ObjectiveCClassEHType};
   }
 
   if (SymName.starts_with(ObjC2IVarPrefix))
     return {SymName.drop_front(ObjC2IVarPrefix.size()),
-            SymbolKind::ObjectiveCInstanceVariable};
-  return {SymName, SymbolKind::GlobalSymbol};
+            EncodeKind::ObjectiveCInstanceVariable};
+  return {SymName, EncodeKind::GlobalSymbol};
 }
 
 } // end namespace MachO.

llvm/lib/TextAPI/SymbolSet.cpp

@@ -11,7 +11,7 @@
 using namespace llvm;
 using namespace llvm::MachO;
 
-Symbol *SymbolSet::addGlobalImpl(SymbolKind Kind, StringRef Name,
+Symbol *SymbolSet::addGlobalImpl(EncodeKind Kind, StringRef Name,
                                  SymbolFlags Flags) {
   Name = copyString(Name);
   auto Result = Symbols.try_emplace(SymbolsMapKey{Kind, Name}, nullptr);
@@ -21,13 +21,13 @@ Symbol *SymbolSet::addGlobalImpl(SymbolKind Kind, StringRef Name,
   return Result.first->second;
 }
 
-Symbol *SymbolSet::addGlobal(SymbolKind Kind, StringRef Name, SymbolFlags Flags,
+Symbol *SymbolSet::addGlobal(EncodeKind 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 {
+const Symbol *SymbolSet::findSymbol(EncodeKind Kind, StringRef Name) const {
   return Symbols.lookup({Kind, Name});
 }