Make DWARFDebugLine use StringRef for dir/file tables. NFC

[probinson]

Summary

From a @dblaikie review comment in D32713.
I wasn't sure whether changing the actual tables was the idea, or just simplifying the extraction.
A StringRef does take up more space, and it's common to have large numbers of directory and file entries; I don't think it's *that* big a deal, but I thought I'd get an opinion from reviewers first.

[aprantl]

I think this looks much nicer!

include/llvm/Support/DataExtractor.h

69 ↗

(On Diff #97374)

\param

76 ↗

(On Diff #97374)

\return

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

 class DWARFDebugLine {
 public:
   DWARFDebugLine(const RelocAddrMap *LineInfoRelocMap)
       : RelocMap(LineInfoRelocMap) {}
 
   struct FileNameEntry {
     FileNameEntry() = default;
 
-    const char *Name = nullptr;
+    StringRef Name = StringRef();
     uint64_t DirIdx = 0;
     uint64_t ModTime = 0;
     uint64_t Length = 0;
   };
 
   struct Prologue {
     Prologue();
 
struct Prologue {
     uint8_t DefaultIsStmt;
     /// This parameter affects the meaning of the special opcodes. See below.
     int8_t LineBase;
     /// This parameter affects the meaning of the special opcodes. See below.
     uint8_t LineRange;
     /// The number assigned to the first special opcode.
     uint8_t OpcodeBase;
     std::vector<uint8_t> StandardOpcodeLengths;
-    std::vector<const char *> IncludeDirectories;
+    std::vector<StringRef> IncludeDirectories;
     std::vector<FileNameEntry> FileNames;
 
     bool IsDWARF64;
 
     uint32_t sizeofTotalLength() const { return IsDWARF64 ? 12 : 4; }
 
     uint32_t sizeofPrologueLength() const { return IsDWARF64 ? 8 : 4; }
 

llvm/trunk/include/llvm/Support/DataExtractor.h

public:
   ///
   /// @return
   ///     A pointer to the C string value in the data. If the offset
   ///     pointed to by \a offset_ptr is out of bounds, or if the
   ///     offset plus the length of the C string is out of bounds,
   ///     NULL will be returned.
   const char *getCStr(uint32_t *offset_ptr) const;
 
+  /// Extract a C string from \a *OffsetPtr.
+  ///
+  /// Returns a StringRef for the C String from the data at the offset
+  /// pointed to by \a OffsetPtr. A variable length NULL terminated C
+  /// string will be extracted and the \a OffsetPtr will be
+  /// updated with the offset of the byte that follows the NULL
+  /// terminator byte.
+  ///
+  /// \param[in,out] OffsetPtr
+  ///     A pointer to an offset within the data that will be advanced
+  ///     by the appropriate number of bytes if the value is extracted
+  ///     correctly. If the offset is out of bounds or there are not
+  ///     enough bytes to extract this value, the offset will be left
+  ///     unmodified.
+  ///
+  /// \return
+  ///     A StringRef for the C string value in the data. If the offset
+  ///     pointed to by \a OffsetPtr is out of bounds, or if the
+  ///     offset plus the length of the C string is out of bounds,
+  ///     a default-initialized StringRef will be returned.
+  StringRef getCStrRef(uint32_t *OffsetPtr) const;
+
   /// Extract an unsigned integer of size \a byte_size from \a
   /// *offset_ptr.
   ///
   /// Extract a single unsigned integer value and update the offset
   /// pointed to by \a offset_ptr. The size of the extracted integer
   /// is specified by the \a byte_size argument. \a byte_size should
   /// have a value greater than or equal to one and less than or equal
   /// to eight since the return value is 64 bits wide. Any

llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

bool DWARFDebugLine::Prologue::parse(DataExtractor DebugLineData,
 
   StandardOpcodeLengths.reserve(OpcodeBase - 1);
   for (uint32_t I = 1; I < OpcodeBase; ++I) {
     uint8_t OpLen = DebugLineData.getU8(OffsetPtr);
     StandardOpcodeLengths.push_back(OpLen);
   }
 
   while (*OffsetPtr < EndPrologueOffset) {
-    const char *S = DebugLineData.getCStr(OffsetPtr);
-    if (S && S[0])
-      IncludeDirectories.push_back(S);
-    else
+    StringRef S = DebugLineData.getCStrRef(OffsetPtr);
+    if (S.empty())
       break;
+    IncludeDirectories.push_back(S);
   }
 
   while (*OffsetPtr < EndPrologueOffset) {
-    const char *Name = DebugLineData.getCStr(OffsetPtr);
-    if (Name && Name[0]) {
-      FileNameEntry FileEntry;
-      FileEntry.Name = Name;
-      FileEntry.DirIdx = DebugLineData.getULEB128(OffsetPtr);
-      FileEntry.ModTime = DebugLineData.getULEB128(OffsetPtr);
-      FileEntry.Length = DebugLineData.getULEB128(OffsetPtr);
-      FileNames.push_back(FileEntry);
-    } else {
-      break;
-    }
+    StringRef Name = DebugLineData.getCStrRef(OffsetPtr);
+    if (Name.empty())
+      break;
   }
 
   if (*OffsetPtr != EndPrologueOffset) {
     fprintf(stderr,
             "warning: parsing line table prologue at 0x%8.8" PRIx64
             " should have ended at 0x%8.8" PRIx64
             " but it ended at 0x%8.8" PRIx64 "\n",
             PrologueOffset, EndPrologueOffset, (uint64_t)*OffsetPtr);

 
 bool DWARFDebugLine::LineTable::getFileNameByIndex(uint64_t FileIndex,
                                                    const char *CompDir,
                                                    FileLineInfoKind Kind,
                                                    std::string &Result) const {
   if (Kind == FileLineInfoKind::None || !hasFileAtIndex(FileIndex))
     return false;
   const FileNameEntry &Entry = Prologue.FileNames[FileIndex - 1];
-  const char *FileName = Entry.Name;
+  StringRef FileName = Entry.Name;
   if (Kind != FileLineInfoKind::AbsoluteFilePath ||
       sys::path::is_absolute(FileName)) {
     Result = FileName;
     return true;
   }
 
   SmallString<16> FilePath;
   uint64_t IncludeDirIndex = Entry.DirIdx;
-  const char *IncludeDir = "";
+  StringRef IncludeDir;
   // Be defensive about the contents of Entry.
   if (IncludeDirIndex > 0 &&
       IncludeDirIndex <= Prologue.IncludeDirectories.size())
     IncludeDir = Prologue.IncludeDirectories[IncludeDirIndex - 1];
 
   // We may still need to append compilation directory of compile unit.
   // We know that FileName is not absolute, the only way to have an
   // absolute path at this point would be if IncludeDir is absolute.

llvm/trunk/lib/Support/DataExtractor.cpp

const char *DataExtractor::getCStr(uint32_t *offset_ptr) const {
   StringRef::size_type pos = Data.find('\0', offset);
   if (pos != StringRef::npos) {
     *offset_ptr = pos + 1;
     return Data.data() + offset;
   }
   return nullptr;
 }
 
+StringRef DataExtractor::getCStrRef(uint32_t *OffsetPtr) const {
+  uint32_t Start = *OffsetPtr;
+  StringRef::size_type Pos = Data.find('\0', Start);
+  if (Pos != StringRef::npos) {
+    *OffsetPtr = Pos + 1;
+    return StringRef(Data.data() + Start, Pos - Start);
+  }
+  return StringRef();
+}
+
 uint64_t DataExtractor::getULEB128(uint32_t *offset_ptr) const {
   uint64_t result = 0;
   if (Data.empty())
     return 0;
 
   unsigned shift = 0;
   uint32_t offset = *offset_ptr;
   uint8_t byte = 0;