[DebugInfo] Fix DebugLine::Prologue::getLength

[jhenderson]

Summary

The function a) returned 32-bits when in DWARF64, the PrologueLength field is 64-bits in size, and b) didn't work for DWARF version 5.

Also deleted some related dead code. With this deletion, getLength is itself dead, but another change is about to make use of it.

[probinson]

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

306

I'd just use += 2 here, with a comment. sizeof(getAddressSize()) took a second to parse, and assumes the getter returns a type that is the same size as the field.

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

32

// + 10 for sizes of DWARF-32 unit length, version, prologue length.

39

// Unit length grows by 8, prologue length by 4.

[jhenderson]

Address review comments.

[probinson]

LGTM

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

struct Prologue {
 
     uint32_t sizeofTotalLength() const { return isDWARF64() ? 12 : 4; }
 
     uint32_t sizeofPrologueLength() const { return isDWARF64() ? 8 : 4; }
 
     bool totalLengthIsValid() const;
 
     /// Length of the prologue in bytes.
-    uint32_t getLength() const {
-      return PrologueLength + sizeofTotalLength() + sizeof(getVersion()) +
-             sizeofPrologueLength();
-    }
-
-    /// Length of the line table data in bytes (not including the prologue).
-    uint32_t getStatementTableLength() const {
-      return TotalLength + sizeofTotalLength() - getLength();
-    }
+    uint64_t getLength() const;
 
     int32_t getMaxLineIncrementForSpecialOpcode() const {
       return LineBase + (int8_t)LineRange - 1;
     }
 
     /// Get DWARF-version aware access to the file name entry at the provided
     /// index.
     const llvm::DWARFDebugLine::FileNameEntry &

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

for (auto Descriptor : *FileDescriptors) {
         break;
       }
     }
     FileNames.push_back(FileEntry);
   }
   return Error::success();
 }
 
+uint64_t DWARFDebugLine::Prologue::getLength() const {
+  uint64_t Length = PrologueLength + sizeofTotalLength() +
+                    sizeof(getVersion()) + sizeofPrologueLength();
+  if (getVersion() >= 5)
+    Length += 2; // Address + Segment selector sizes.
+  return Length;
+}
+
 Error DWARFDebugLine::Prologue::parse(
     const DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
     function_ref<void(Error)> RecoverableErrorCallback, const DWARFContext &Ctx,
     const DWARFUnit *U) {
   const uint64_t PrologueOffset = *OffsetPtr;
 
   clear();
   TotalLength = DebugLineData.getRelocatedValue(4, OffsetPtr);

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

 namespace {
 struct CommonFixture {
   CommonFixture()
       : LineData("", true, 0), Recoverable(Error::success()),
         RecordRecoverable(std::bind(&CommonFixture::recordRecoverable, this,
                                     std::placeholders::_1)),
         Unrecoverable(Error::success()),
         RecordUnrecoverable(std::bind(&CommonFixture::recordUnrecoverable, this,
                                       std::placeholders::_1)){};
 
   ~CommonFixture() {
     EXPECT_FALSE(Recoverable);
     EXPECT_FALSE(Unrecoverable);
   }
 
   bool setupGenerator(uint16_t Version = 4, uint8_t AddrSize = 8) {
     AddressSize = AddrSize;
     Triple T =
         getDefaultTargetTripleForAddrSize(AddressSize == 0 ? 8 : AddressSize);
     if (!isConfigurationSupported(T))
       return false;
     auto ExpectedGenerator = Generator::create(T, Version);
     if (ExpectedGenerator)
       Gen.reset(ExpectedGenerator->release());
TEST_F(DebugLineBasicFixture, GetOrParseLineTableAtInvalidOffsetAfterData) {
   LT.setCustomPrologue({{0, LineTable::Byte}});
 
   generate();
 
   checkGetOrParseLineTableEmitsFatalError(
       "offset 0x00000001 is not a valid debug line section offset", 1);
 }
 
+TEST_P(DebugLineParameterisedFixture, PrologueGetLength) {
+  if (!setupGenerator(Version))
+    return;
+  LineTable &LT = Gen->addLineTable(Format);
+  DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue();
+  LT.setPrologue(Prologue);
+  generate();
+
+  // + 10 for sizes of DWARF-32 unit length, version, prologue length.
+  uint64_t ExpectedLength = Prologue.PrologueLength + 10;
+  if (Version == 5)
+    // Add address and segment selector size fields.
+    ExpectedLength += 2;
+  if (Format == DWARF64)
+    // Unit length grows by 8, prologue length by 4.
+    ExpectedLength += 12;
+
+  auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context,
+                                                    nullptr, RecordRecoverable);
+  ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
+  EXPECT_EQ((*ExpectedLineTable)->Prologue.getLength(), ExpectedLength);
+}
+
 TEST_P(DebugLineParameterisedFixture, GetOrParseLineTableValidTable) {
   if (!setupGenerator(Version))
     return;
 
   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
                (Format == DWARF64 ? "DWARF64" : "DWARF32"));
 
   LineTable &LT = Gen->addLineTable(Format);