[Debuginfo][DWARF][NFC] Refactor DwarfStringPoolEntryRef - remove isIndexed().

[avl]

Summary

This patch is extraction from the https://reviews.llvm.org/D126883.
It removes DwarfStringPoolEntryRef::isIndexed() and isIndexed bit
since they are not used.

[dblaikie]

Sounds good, thanks!

[avl]

@dblaikie Thank you for the review!

llvm/include/llvm/CodeGen/DwarfStringPoolEntry.h

struct DwarfStringPoolEntry {
   uint64_t Offset;
   unsigned Index;
 
   bool isIndexed() const { return Index != NotIndexed; }
 };
 
 /// String pool entry reference.
 class DwarfStringPoolEntryRef {
-  PointerIntPair<const StringMapEntry<DwarfStringPoolEntry> *, 1, bool>
-      MapEntryAndIndexed;
+  const StringMapEntry<DwarfStringPoolEntry> *MapEntry = nullptr;
 
   const StringMapEntry<DwarfStringPoolEntry> *getMapEntry() const {
-    return MapEntryAndIndexed.getPointer();
+    return MapEntry;
   }
 
 public:
   DwarfStringPoolEntryRef() = default;
-  DwarfStringPoolEntryRef(const StringMapEntry<DwarfStringPoolEntry> &Entry,
-                          bool Indexed)
-      : MapEntryAndIndexed(&Entry, Indexed) {}
+  DwarfStringPoolEntryRef(const StringMapEntry<DwarfStringPoolEntry> &Entry)
+      : MapEntry(&Entry) {}
 
   explicit operator bool() const { return getMapEntry(); }
   MCSymbol *getSymbol() const {
     assert(getMapEntry()->second.Symbol && "No symbol available!");
     return getMapEntry()->second.Symbol;
   }
   uint64_t getOffset() const { return getMapEntry()->second.Offset; }
-  bool isIndexed() const { return MapEntryAndIndexed.getInt(); }
   unsigned getIndex() const {
-    assert(isIndexed());
     assert(getMapEntry()->getValue().isIndexed());
     return getMapEntry()->second.Index;
   }
   StringRef getString() const { return getMapEntry()->first(); }
   /// Return the entire string pool entry for convenience.
   DwarfStringPoolEntry getEntry() const { return getMapEntry()->getValue(); }
 
   bool operator==(const DwarfStringPoolEntryRef &X) const {

llvm/lib/CodeGen/AsmPrinter/DwarfStringPool.cpp

if (I.second) {
     NumBytes += Str.size() + 1;
   }
   return *I.first;
 }
 
 DwarfStringPool::EntryRef DwarfStringPool::getEntry(AsmPrinter &Asm,
                                                     StringRef Str) {
   auto &MapEntry = getEntryImpl(Asm, Str);
-  return EntryRef(MapEntry, false);
+  return EntryRef(MapEntry);
 }
 
 DwarfStringPool::EntryRef DwarfStringPool::getIndexedEntry(AsmPrinter &Asm,
                                                            StringRef Str) {
   auto &MapEntry = getEntryImpl(Asm, Str);
   if (!MapEntry.getValue().isIndexed())
     MapEntry.getValue().Index = NumIndexedStrings++;
-  return EntryRef(MapEntry, true);
+  return EntryRef(MapEntry);
 }
 
 void DwarfStringPool::emitStringOffsetsTableHeader(AsmPrinter &Asm,
                                                    MCSection *Section,
                                                    MCSymbol *StartSym) {
   if (getNumIndexedStrings() == 0)
     return;
   Asm.OutStreamer->SwitchSection(Section);

llvm/lib/CodeGen/NonRelocatableStringpool.cpp

DwarfStringPoolEntryRef NonRelocatableStringpool::getEntry(StringRef S) {
   auto I = Strings.insert({S, DwarfStringPoolEntry()});
   auto &Entry = I.first->second;
   if (I.second || !Entry.isIndexed()) {
     Entry.Index = NumEntries++;
     Entry.Offset = CurrentEndOffset;
     Entry.Symbol = nullptr;
     CurrentEndOffset += S.size() + 1;
   }
-  return DwarfStringPoolEntryRef(*I.first, true);
+  return DwarfStringPoolEntryRef(*I.first);
 }
 
 StringRef NonRelocatableStringpool::internString(StringRef S) {
   DwarfStringPoolEntry Entry{nullptr, 0, DwarfStringPoolEntry::NotIndexed};
 
   if (Translator)
     S = Translator(S);
 
   auto InsertResult = Strings.insert({S, Entry});
   return InsertResult.first->getKey();
 }
 
 std::vector<DwarfStringPoolEntryRef>
 NonRelocatableStringpool::getEntriesForEmission() const {
   std::vector<DwarfStringPoolEntryRef> Result;
   Result.reserve(Strings.size());
   for (const auto &E : Strings)
     if (E.getValue().isIndexed())
-      Result.emplace_back(E, true);
+      Result.emplace_back(E);
   llvm::sort(Result, [](const DwarfStringPoolEntryRef A,
                         const DwarfStringPoolEntryRef B) {
     return A.getIndex() < B.getIndex();
   });
   return Result;
 }
 
 } // namespace llvm

llvm/unittests/CodeGen/DIEHashTest.cpp

auto ExpectedTestPrinter = TestAsmPrinter::create(
         sys::getDefaultTargetTriple(), /*DwarfVersion=*/4, dwarf::DWARF32);
     ASSERT_THAT_EXPECTED(ExpectedTestPrinter, Succeeded());
     TestPrinter = std::move(ExpectedTestPrinter.get());
   }
 
 public:
   DIEString getString(StringRef S) {
     DwarfStringPoolEntry Entry = {nullptr, 1, 1};
-    return DIEString(DwarfStringPoolEntryRef(
-        *Pool.insert(std::make_pair(S, Entry)).first, Entry.isIndexed()));
+    return DIEString(
+        DwarfStringPoolEntryRef(*Pool.insert(std::make_pair(S, Entry)).first));
   }
 
   AsmPrinter *getAsmPrinter() {
     if (!TestPrinter)
       setupTestPrinter();
     return TestPrinter ? TestPrinter->getAP() : nullptr;
   }
 };