[DebugInfo] Make the offset of string pool entries 64-bit (18/19).

[ikudrin]

Summary

The string pool is shared among several units in the case of LTO, and it potentially can exceed the limit of 4GiB for an extremely large application. As it is now possible to emit 64-bit debugging info, the limitation can be removed.

[dblaikie]

Guess this is untestable without creating giant output files?

[ikudrin]

In D87025#2253890, @dblaikie wrote:

Guess this is untestable without creating giant output files?

I think so.

llvm/include/llvm/CodeGen/DwarfStringPoolEntry.h

 
 class MCSymbol;
 
 /// Data for a string pool entry.
 struct DwarfStringPoolEntry {
   static constexpr unsigned NotIndexed = -1;
 
   MCSymbol *Symbol;
-  unsigned Offset;
+  uint64_t Offset;
   unsigned Index;
 
   bool isIndexed() const { return Index != NotIndexed; }
 };
 
 /// String pool entry reference.
 class DwarfStringPoolEntryRef {
   PointerIntPair<const StringMapEntry<DwarfStringPoolEntry> *, 1, bool>
DwarfStringPoolEntryRef(const StringMapEntry<DwarfStringPoolEntry> &Entry,
                           bool Indexed)
       : MapEntryAndIndexed(&Entry, Indexed) {}
 
   explicit operator bool() const { return getMapEntry(); }
   MCSymbol *getSymbol() const {
     assert(getMapEntry()->second.Symbol && "No symbol available!");
     return getMapEntry()->second.Symbol;
   }
-  unsigned getOffset() const { return getMapEntry()->second.Offset; }
+  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.

llvm/include/llvm/CodeGen/NonRelocatableStringpool.h

NonRelocatableStringpool(
     if (PutEmptyString)
       EmptyString = getEntry("");
   }
 
   DwarfStringPoolEntryRef getEntry(StringRef S);
 
   /// Get the offset of string \p S in the string table. This can insert a new
   /// element or return the offset of a pre-existing one.
-  uint32_t getStringOffset(StringRef S) { return getEntry(S).getOffset(); }
+  uint64_t getStringOffset(StringRef S) { return getEntry(S).getOffset(); }
 
   /// Get permanent storage for \p S (but do not necessarily emit \p S in the
   /// output section). A latter call to getStringOffset() with the same string
   /// will chain it though.
   ///
   /// \returns The StringRef that points to permanent storage to use
   /// in place of \p S.
   StringRef internString(StringRef S);
 
   uint64_t getSize() { return CurrentEndOffset; }
 
   /// Return the list of strings to be emitted. This does not contain the
   /// strings which were added via internString only.
   std::vector<DwarfStringPoolEntryRef> getEntriesForEmission() const;
 
 private:
   MapTy Strings;
-  uint32_t CurrentEndOffset = 0;
+  uint64_t CurrentEndOffset = 0;
   unsigned NumEntries = 0;
   DwarfStringPoolEntryRef EmptyString;
   std::function<StringRef(StringRef Input)> Translator;
 };
 
 /// Helper for making strong types.
 template <typename T, typename S> class StrongType : public T {
 public:

llvm/lib/CodeGen/AsmPrinter/DwarfStringPool.h

 // Collection of strings for this unit and assorted symbols.
 // A String->Symbol mapping of strings used by indirect
 // references.
 class DwarfStringPool {
   using EntryTy = DwarfStringPoolEntry;
 
   StringMap<EntryTy, BumpPtrAllocator &> Pool;
   StringRef Prefix;
-  unsigned NumBytes = 0;
+  uint64_t NumBytes = 0;
   unsigned NumIndexedStrings = 0;
   bool ShouldCreateSymbols;
 
   StringMapEntry<EntryTy> &getEntryImpl(AsmPrinter &Asm, StringRef Str);
 
 public:
   using EntryRef = DwarfStringPoolEntryRef;
 

llvm/lib/CodeGen/AsmPrinter/DwarfStringPool.cpp

DwarfStringPool::getEntryImpl(AsmPrinter &Asm, StringRef Str) {
   auto I = Pool.insert(std::make_pair(Str, EntryTy()));
   auto &Entry = I.first->second;
   if (I.second) {
     Entry.Index = EntryTy::NotIndexed;
     Entry.Offset = NumBytes;
     Entry.Symbol = ShouldCreateSymbols ? Asm.createTempSymbol(Prefix) : nullptr;
 
     NumBytes += Str.size() + 1;
-    assert(NumBytes > Entry.Offset && "Unexpected overflow");
   }
   return *I.first;
 }
 
 DwarfStringPool::EntryRef DwarfStringPool::getEntry(AsmPrinter &Asm,
                                                     StringRef Str) {
   auto &MapEntry = getEntryImpl(Asm, Str);
   return EntryRef(MapEntry, false);