Remove unused features from StringRefZ and move it to Symbols.h.

[ruiu]

Summary

Remove unused features from StringRefZ and move it to Symbols.h.

[• espindola]

LGTM

lld/ELF/Symbols.h

41

Just make it a struct if it is all public .

lld/ELF/Symbols.h

 class BitcodeFile;
 class BssSection;
 class InputFile;
 class LazyObjFile;
 template <class ELFT> class ObjFile;
 class OutputSection;
 template <class ELFT> class SharedFile;
 
+// This is a StringRef-like container that doesn't run strlen() automatically.
+//
+// ELF string tables contain a lot of null-terminated strings. Most of them
+// are not necessary for the linker because they are names of local symbols,
+// and the linker doesn't use local symbol names for name resolution. So, we
+// use this class to represents strings read from string tables.
+class StringRefZ {
+public:
+  StringRefZ(const char *S) : Data(S), Size(-1) {}
+  StringRefZ(StringRef S) : Data(S.data()), Size(S.size()) {}
+
+  const char *Data;
+  const uint32_t Size;
+};
+
 // The base class for real symbol classes.
 class Symbol {
 public:
   enum Kind {
     DefinedKind,
     SharedKind,
     UndefinedKind,
     LazyArchiveKind,
     LazyObjectKind,
   };
 
   Kind kind() const { return static_cast<Kind>(SymbolKind); }
 
   // The file from which this symbol was created.
   InputFile *File;
 
 protected:
-  const char *NameStart;
+  const char *NameData;
   mutable uint32_t NameSize;
 
 public:
   uint32_t DynsymIndex = 0;
   uint32_t GotIndex = -1;
   uint32_t GotPltIndex = -1;
   uint32_t PltIndex = -1;
   uint32_t GlobalDynIndex = -1;
bool isLazy() const {
     return SymbolKind == LazyArchiveKind || SymbolKind == LazyObjectKind;
   }
 
   // True if this is an undefined weak symbol.
   bool isUndefWeak() const { return isWeak() && isUndefined(); }
 
   StringRef getName() const {
     if (NameSize == (uint32_t)-1)
-      NameSize = strlen(NameStart);
-    return StringRef(NameStart, NameSize);
+      NameSize = strlen(NameData);
+    return StringRef(NameData, NameSize);
   }
   void parseSymbolVersion();
 
   bool isInGot() const { return GotIndex != -1U; }
   bool isInPlt() const { return PltIndex != -1U; }
 
   uint64_t getVA(int64_t Addend = 0) const;
 
   uint64_t getGotOffset() const;
   uint64_t getGotVA() const;
   uint64_t getGotPltOffset() const;
   uint64_t getGotPltVA() const;
   uint64_t getPltVA() const;
   uint64_t getSize() const;
   OutputSection *getOutputSection() const;
 
 protected:
   Symbol(Kind K, InputFile *File, StringRefZ Name, uint8_t Binding,
          uint8_t StOther, uint8_t Type)
-      : File(File), NameStart(Name.data()), NameSize(Name.rawSize()),
-        Binding(Binding), Type(Type), StOther(StOther), SymbolKind(K),
-        NeedsPltAddr(false), IsInGlobalMipsGot(false), Is32BitMipsGot(false),
-        IsInIplt(false), IsInIgot(false), IsPreemptible(false),
-        Used(!Config->GcSections) {}
+      : File(File), NameData(Name.Data), NameSize(Name.Size), Binding(Binding),
+        Type(Type), StOther(StOther), SymbolKind(K), NeedsPltAddr(false),
+        IsInGlobalMipsGot(false), Is32BitMipsGot(false), IsInIplt(false),
+        IsInIgot(false), IsPreemptible(false), Used(!Config->GcSections) {}
 
 public:
   // True the symbol should point to its PLT entry.
   // For SharedSymbol only.
   unsigned NeedsPltAddr : 1;
   // True if this symbol has an entry in the global part of MIPS GOT.
   unsigned IsInGlobalMipsGot : 1;
 

lld/include/lld/Common/Strings.h

 // Returns a demangled C++ symbol name. If Name is not a mangled
 // name, it returns Optional::None.
 llvm::Optional<std::string> demangleItanium(llvm::StringRef Name);
 llvm::Optional<std::string> demangleMSVC(llvm::StringRef S);
 
 std::vector<uint8_t> parseHex(llvm::StringRef S);
 bool isValidCIdentifier(llvm::StringRef S);
 
-// This is a lazy version of StringRef. String size is computed lazily
-// when it is needed. It is more efficient than StringRef to instantiate
-// if you have a string whose size is unknown.
-//
-// COFF and ELF string tables contain a lot of null-terminated strings.
-// Most of them are not necessary for the linker because they are names
-// of local symbols and the linker doesn't use local symbol names for
-// name resolution. So, we use this class to represents strings read
-// from string tables.
-class StringRefZ {
-public:
-  StringRefZ() : Start(nullptr), Size(0) {}
-  StringRefZ(const char *S, size_t Size) : Start(S), Size(Size) {}
-
-  /*implicit*/ StringRefZ(const char *S) : Start(S), Size(-1) {}
-
-  /*implicit*/ StringRefZ(llvm::StringRef S)
-      : Start(S.data()), Size(S.size()) {}
-
-  const char *data() const { return Start; }
-  size_t rawSize() const { return Size; };
-
-  operator llvm::StringRef() const {
-    if (Size == (size_t)-1)
-      Size = strlen(Start);
-    return {Start, Size};
-  }
-
-private:
-  const char *Start;
-  mutable size_t Size;
-};
-
 // This class represents multiple glob patterns.
 class StringMatcher {
 public:
   StringMatcher() = default;
   explicit StringMatcher(llvm::ArrayRef<llvm::StringRef> Pat);
 
   bool match(llvm::StringRef S) const;