From 34f3b069d430a17f525cadd1368b1d12b1611421 Mon Sep 17 00:00:00 2001 From: James Henderson Date: Mon, 10 Feb 2020 14:40:47 +0000 Subject: [PATCH] [NFC] Fix line endings --- .../DebugInfo/DWARF/DWARFDebugLineTest.cpp | 1808 ++++++++--------- 1 file changed, 904 insertions(+), 904 deletions(-) diff --git a/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp b/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp index ba3bb540376..0adac7c9ca9 100644 --- a/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp +++ b/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp @@ -1,904 +1,904 @@ -//===- DWARFDebugLineTest.cpp ---------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#include "DwarfGenerator.h" -#include "DwarfUtils.h" -#include "llvm/DebugInfo/DWARF/DWARFContext.h" -#include "llvm/DebugInfo/DWARF/DWARFDebugLine.h" -#include "llvm/Object/ObjectFile.h" -#include "llvm/Testing/Support/Error.h" -#include "gtest/gtest.h" - -using namespace llvm; -using namespace dwarf; -using namespace dwarfgen; -using namespace object; -using namespace utils; -using namespace testing; - -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()); - return true; - } - - void generate() { - Context = createContext(); - assert(Context != nullptr && "test state is not valid"); - const DWARFObject &Obj = Context->getDWARFObj(); - uint8_t TargetAddrSize = AddressSize == 0 ? 8 : AddressSize; - LineData = DWARFDataExtractor( - Obj, Obj.getLineSection(), - getDefaultTargetTripleForAddrSize(TargetAddrSize).isLittleEndian(), - AddressSize); - } - - std::unique_ptr createContext() { - if (!Gen) - return nullptr; - StringRef FileBytes = Gen->generate(); - MemoryBufferRef FileBuffer(FileBytes, "dwarf"); - auto Obj = object::ObjectFile::createObjectFile(FileBuffer); - if (Obj) - return DWARFContext::create(**Obj); - return nullptr; - } - - DWARFDebugLine::SectionParser setupParser() { - LineTable < = Gen->addLineTable(DWARF32); - LT.addExtendedOpcode(9, DW_LNE_set_address, {{0xadd4e55, LineTable::Quad}}); - LT.addStandardOpcode(DW_LNS_copy, {}); - LT.addByte(0xaa); - LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); - - LineTable <2 = Gen->addLineTable(DWARF64); - LT2.addExtendedOpcode(9, DW_LNE_set_address, - {{0x11223344, LineTable::Quad}}); - LT2.addStandardOpcode(DW_LNS_copy, {}); - LT2.addByte(0xbb); - LT2.addExtendedOpcode(1, DW_LNE_end_sequence, {}); - - generate(); - - return DWARFDebugLine::SectionParser(LineData, *Context, CUs, TUs); - } - - void recordRecoverable(Error Err) { - Recoverable = joinErrors(std::move(Recoverable), std::move(Err)); - } - void recordUnrecoverable(Error Err) { - Unrecoverable = joinErrors(std::move(Unrecoverable), std::move(Err)); - } - - void checkError(ArrayRef ExpectedMsgs, Error Err) { - ASSERT_TRUE(Err.operator bool()); - size_t WhichMsg = 0; - Error Remaining = - handleErrors(std::move(Err), [&](const ErrorInfoBase &Actual) { - ASSERT_LT(WhichMsg, ExpectedMsgs.size()); - // Use .str(), because googletest doesn't visualise a StringRef - // properly. - EXPECT_EQ(Actual.message(), ExpectedMsgs[WhichMsg++].str()); - }); - EXPECT_EQ(WhichMsg, ExpectedMsgs.size()); - EXPECT_FALSE(Remaining); - } - - void checkError(StringRef ExpectedMsg, Error Err) { - checkError(ArrayRef{ExpectedMsg}, std::move(Err)); - } - - void checkGetOrParseLineTableEmitsFatalError(StringRef ExpectedMsg, - uint64_t Offset = 0) { - auto ExpectedLineTable = Line.getOrParseLineTable( - LineData, Offset, *Context, nullptr, RecordRecoverable); - EXPECT_FALSE(ExpectedLineTable); - EXPECT_FALSE(Recoverable); - - checkError(ExpectedMsg, ExpectedLineTable.takeError()); - } - - void checkGetOrParseLineTableEmitsFatalError(ArrayRef ExpectedMsgs, - uint64_t Offset = 0) { - auto ExpectedLineTable = Line.getOrParseLineTable( - LineData, Offset, *Context, nullptr, RecordRecoverable); - EXPECT_FALSE(ExpectedLineTable); - EXPECT_FALSE(Recoverable); - - checkError(ExpectedMsgs, ExpectedLineTable.takeError()); - } - - uint8_t AddressSize; - std::unique_ptr Gen; - std::unique_ptr Context; - DWARFDataExtractor LineData; - DWARFDebugLine Line; - Error Recoverable; - std::function RecordRecoverable; - Error Unrecoverable; - std::function RecordUnrecoverable; - - SmallVector, 2> CUs; - SmallVector, 2> TUs; -}; - -// Fixtures must derive from "Test", but parameterised fixtures from -// "TestWithParam". It does not seem possible to inherit from both, so we share -// the common state in a separate class, inherited by the two fixture classes. -struct DebugLineBasicFixture : public Test, public CommonFixture {}; - -struct DebugLineParameterisedFixture - : public TestWithParam>, - public CommonFixture { - void SetUp() { std::tie(Version, Format) = GetParam(); } - - uint16_t Version; - DwarfFormat Format; -}; - -void checkDefaultPrologue(uint16_t Version, DwarfFormat Format, - DWARFDebugLine::Prologue Prologue, - uint64_t BodyLength) { - // Check version specific fields and values. - uint64_t UnitLength; - uint64_t PrologueLength; - switch (Version) { - case 4: - PrologueLength = 36; - UnitLength = PrologueLength + 2; - EXPECT_EQ(Prologue.MaxOpsPerInst, 1u); - break; - case 2: - case 3: - PrologueLength = 35; - UnitLength = PrologueLength + 2; - break; - case 5: - PrologueLength = 39; - UnitLength = PrologueLength + 4; - EXPECT_EQ(Prologue.getAddressSize(), 8u); - EXPECT_EQ(Prologue.SegSelectorSize, 0u); - break; - default: - llvm_unreachable("unsupported DWARF version"); - } - UnitLength += BodyLength + (Format == DWARF32 ? 4 : 8); - - EXPECT_EQ(Prologue.TotalLength, UnitLength); - EXPECT_EQ(Prologue.PrologueLength, PrologueLength); - EXPECT_EQ(Prologue.MinInstLength, 1u); - EXPECT_EQ(Prologue.DefaultIsStmt, 1u); - EXPECT_EQ(Prologue.LineBase, -5); - EXPECT_EQ(Prologue.LineRange, 14u); - EXPECT_EQ(Prologue.OpcodeBase, 13u); - std::vector ExpectedLengths = {0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1}; - EXPECT_EQ(Prologue.StandardOpcodeLengths, ExpectedLengths); - ASSERT_EQ(Prologue.IncludeDirectories.size(), 1u); - ASSERT_EQ(Prologue.IncludeDirectories[0].getForm(), DW_FORM_string); - EXPECT_STREQ(*Prologue.IncludeDirectories[0].getAsCString(), "a dir"); - ASSERT_EQ(Prologue.FileNames.size(), 1u); - ASSERT_EQ(Prologue.FileNames[0].Name.getForm(), DW_FORM_string); - EXPECT_STREQ(*Prologue.FileNames[0].Name.getAsCString(), "a file"); -} - -TEST_F(DebugLineBasicFixture, GetOrParseLineTableAtInvalidOffset) { - if (!setupGenerator()) - return; - generate(); - - checkGetOrParseLineTableEmitsFatalError( - "offset 0x00000000 is not a valid debug line section offset", 0); - // Repeat to show that an error is reported each time. - checkGetOrParseLineTableEmitsFatalError( - "offset 0x00000000 is not a valid debug line section offset", 0); - // Show that an error is reported for later offsets too. - checkGetOrParseLineTableEmitsFatalError( - "offset 0x00000001 is not a valid debug line section offset", 1); -} - -TEST_F(DebugLineBasicFixture, GetOrParseLineTableAtInvalidOffsetAfterData) { - if (!setupGenerator()) - return; - - LineTable < = Gen->addLineTable(); - 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 < = 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 < = Gen->addLineTable(Format); - LT.addExtendedOpcode(9, DW_LNE_set_address, {{0xadd4e55, LineTable::Quad}}); - LT.addStandardOpcode(DW_LNS_copy, {}); - LT.addByte(0xaa); - LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); - - LineTable <2 = Gen->addLineTable(Format); - LT2.addExtendedOpcode(9, DW_LNE_set_address, {{0x11223344, LineTable::Quad}}); - LT2.addStandardOpcode(DW_LNS_copy, {}); - LT2.addByte(0xbb); - LT2.addExtendedOpcode(1, DW_LNE_end_sequence, {}); - LT2.addExtendedOpcode(9, DW_LNE_set_address, {{0x55667788, LineTable::Quad}}); - LT2.addStandardOpcode(DW_LNS_copy, {}); - LT2.addByte(0xcc); - LT2.addExtendedOpcode(1, DW_LNE_end_sequence, {}); - - generate(); - - auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, - nullptr, RecordRecoverable); - ASSERT_TRUE(ExpectedLineTable.operator bool()); - EXPECT_FALSE(Recoverable); - const DWARFDebugLine::LineTable *Expected = *ExpectedLineTable; - checkDefaultPrologue(Version, Format, Expected->Prologue, 16); - EXPECT_EQ(Expected->Sequences.size(), 1u); - - uint64_t SecondOffset = - Expected->Prologue.sizeofTotalLength() + Expected->Prologue.TotalLength; - Recoverable = Error::success(); - auto ExpectedLineTable2 = Line.getOrParseLineTable( - LineData, SecondOffset, *Context, nullptr, RecordRecoverable); - ASSERT_TRUE(ExpectedLineTable2.operator bool()); - EXPECT_FALSE(Recoverable); - const DWARFDebugLine::LineTable *Expected2 = *ExpectedLineTable2; - checkDefaultPrologue(Version, Format, Expected2->Prologue, 32); - EXPECT_EQ(Expected2->Sequences.size(), 2u); - - EXPECT_NE(Expected, Expected2); - - // Check that if the same offset is requested, the exact same pointer is - // returned. - Recoverable = Error::success(); - auto ExpectedLineTable3 = Line.getOrParseLineTable( - LineData, 0, *Context, nullptr, RecordRecoverable); - ASSERT_TRUE(ExpectedLineTable3.operator bool()); - EXPECT_FALSE(Recoverable); - EXPECT_EQ(Expected, *ExpectedLineTable3); - - Recoverable = Error::success(); - auto ExpectedLineTable4 = Line.getOrParseLineTable( - LineData, SecondOffset, *Context, nullptr, RecordRecoverable); - ASSERT_TRUE(ExpectedLineTable4.operator bool()); - EXPECT_FALSE(Recoverable); - EXPECT_EQ(Expected2, *ExpectedLineTable4); - - // TODO: Add tests that show that the body of the programs have been read - // correctly. -} - -TEST_F(DebugLineBasicFixture, ErrorForReservedLength) { - if (!setupGenerator()) - return; - - LineTable < = Gen->addLineTable(); - LT.setCustomPrologue({{0xfffffff0, LineTable::Long}}); - - generate(); - - checkGetOrParseLineTableEmitsFatalError( - "parsing line table prologue at offset 0x00000000 unsupported reserved " - "unit length found of value 0xfffffff0"); -} - -TEST_F(DebugLineBasicFixture, ErrorForLowVersion) { - if (!setupGenerator()) - return; - - LineTable < = Gen->addLineTable(); - LT.setCustomPrologue( - {{LineTable::Half, LineTable::Long}, {1, LineTable::Half}}); - - generate(); - - checkGetOrParseLineTableEmitsFatalError( - "parsing line table prologue at offset " - "0x00000000 found unsupported version " - "0x01"); -} - -TEST_F(DebugLineBasicFixture, ErrorForInvalidV5IncludeDirTable) { - if (!setupGenerator(5)) - return; - - LineTable < = Gen->addLineTable(); - LT.setCustomPrologue({ - {19, LineTable::Long}, // unit length - {5, LineTable::Half}, // version - {8, LineTable::Byte}, // addr size - {0, LineTable::Byte}, // segment selector size - {11, LineTable::Long}, // prologue length - {1, LineTable::Byte}, // min instruction length - {1, LineTable::Byte}, // max ops per instruction - {1, LineTable::Byte}, // default is_stmt - {0, LineTable::Byte}, // line base - {14, LineTable::Byte}, // line range - {2, LineTable::Byte}, // opcode base (small to reduce the amount of - // setup required). - {0, LineTable::Byte}, // standard opcode lengths - {0, LineTable::Byte}, // directory entry format count (should not be - // zero). - {0, LineTable::ULEB}, // directories count - {0, LineTable::Byte}, // file name entry format count - {0, LineTable::ULEB} // file name entry count - }); - - generate(); - - auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, - nullptr, RecordRecoverable); - EXPECT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); - - checkError( - {"parsing line table prologue at 0x00000000 found an invalid directory " - "or file table description at 0x00000014", - "failed to parse entry content descriptions because no path was found"}, - std::move(Recoverable)); -} - -TEST_P(DebugLineParameterisedFixture, ErrorForTooLargePrologueLength) { - if (!setupGenerator(Version)) - return; - - SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " + - (Format == DWARF64 ? "DWARF64" : "DWARF32")); - - LineTable < = Gen->addLineTable(Format); - DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue(); - ++Prologue.PrologueLength; - LT.setPrologue(Prologue); - - generate(); - - auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, - nullptr, RecordRecoverable); - ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); - DWARFDebugLine::LineTable Result(**ExpectedLineTable); - // Undo the earlier modification so that it can be compared against a - // "default" prologue. - --Result.Prologue.PrologueLength; - checkDefaultPrologue(Version, Format, Result.Prologue, 0); - - uint64_t ExpectedEnd = - Prologue.TotalLength + 1 + Prologue.sizeofTotalLength(); - checkError( - (Twine("parsing line table prologue at 0x00000000 should have ended at " - "0x000000") + - Twine::utohexstr(ExpectedEnd) + " but it ended at 0x000000" + - Twine::utohexstr(ExpectedEnd - 1)) - .str(), - std::move(Recoverable)); -} - -TEST_P(DebugLineParameterisedFixture, ErrorForTooShortPrologueLength) { - if (!setupGenerator(Version)) - return; - - SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " + - (Format == DWARF64 ? "DWARF64" : "DWARF32")); - - LineTable < = Gen->addLineTable(Format); - DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue(); - // FIXME: Ideally, we'd test for 1 less than expected, but the code does not - // currently fail if missing only the terminator of a v2-4 file table. - if (Version < 5) - Prologue.PrologueLength -= 2; - else - Prologue.PrologueLength -= 1; - LT.setPrologue(Prologue); - - generate(); - - auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, - nullptr, RecordRecoverable); - ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); - DWARFDebugLine::LineTable Result(**ExpectedLineTable); - // Undo the earlier modification so that it can be compared against a - // "default" prologue. - if (Version < 5) - Result.Prologue.PrologueLength += 2; - else - Result.Prologue.PrologueLength += 1; - checkDefaultPrologue(Version, Format, Result.Prologue, 0); - - uint64_t ExpectedEnd = - Prologue.TotalLength - 1 + Prologue.sizeofTotalLength(); - if (Version < 5) - --ExpectedEnd; - checkError( - (Twine("parsing line table prologue at 0x00000000 should have ended at " - "0x000000") + - Twine::utohexstr(ExpectedEnd) + " but it ended at 0x000000" + - Twine::utohexstr(ExpectedEnd + 1)) - .str(), - std::move(Recoverable)); -} - -INSTANTIATE_TEST_CASE_P( - LineTableTestParams, DebugLineParameterisedFixture, - Values(std::make_pair( - 2, DWARF32), // Test lower-bound of v2-3 fields and DWARF32. - std::make_pair(3, DWARF32), // Test upper-bound of v2-3 fields. - std::make_pair(4, DWARF64), // Test v4 fields and DWARF64. - std::make_pair(5, DWARF32), std::make_pair(5, DWARF64)), ); - -TEST_F(DebugLineBasicFixture, ErrorForExtendedOpcodeLengthSmallerThanExpected) { - if (!setupGenerator()) - return; - - LineTable < = Gen->addLineTable(); - LT.addByte(0xaa); - // The Length should be 1 + sizeof(ULEB) for a set discriminator opcode. - // The operand will be read for both the discriminator opcode and then parsed - // again as DW_LNS_negate_stmt, to respect the claimed length. - LT.addExtendedOpcode(1, DW_LNE_set_discriminator, - {{DW_LNS_negate_stmt, LineTable::ULEB}}); - LT.addByte(0xbb); - LT.addStandardOpcode(DW_LNS_const_add_pc, {}); - LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); - - generate(); - - auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, - nullptr, RecordRecoverable); - checkError( - "unexpected line op length at offset 0x00000031 expected 0x01 found 0x02", - std::move(Recoverable)); - ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); - ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 3u); - EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u); - EXPECT_EQ((*ExpectedLineTable)->Rows[1].IsStmt, 0u); - EXPECT_EQ((*ExpectedLineTable)->Rows[1].Discriminator, DW_LNS_negate_stmt); -} - -TEST_F(DebugLineBasicFixture, ErrorForExtendedOpcodeLengthLargerThanExpected) { - if (!setupGenerator()) - return; - - LineTable < = Gen->addLineTable(); - LT.addByte(0xaa); - LT.addStandardOpcode(DW_LNS_const_add_pc, {}); - // The Length should be 1 for an end sequence opcode. - LT.addExtendedOpcode(2, DW_LNE_end_sequence, {}); - // The negate statement opcode will be skipped. - LT.addStandardOpcode(DW_LNS_negate_stmt, {}); - LT.addByte(0xbb); - LT.addStandardOpcode(DW_LNS_const_add_pc, {}); - LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); - - generate(); - - auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, - nullptr, RecordRecoverable); - checkError( - "unexpected line op length at offset 0x00000032 expected 0x02 found 0x01", - std::move(Recoverable)); - ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); - ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 4u); - EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 2u); - ASSERT_EQ((*ExpectedLineTable)->Sequences[1].FirstRowIndex, 2u); - EXPECT_EQ((*ExpectedLineTable)->Rows[2].IsStmt, 1u); -} - -TEST_F(DebugLineBasicFixture, ErrorForUnitLengthTooLarge) { - if (!setupGenerator()) - return; - - LineTable &Padding = Gen->addLineTable(); - // Add some padding to show that a non-zero offset is handled correctly. - Padding.setCustomPrologue({{0, LineTable::Byte}}); - LineTable < = Gen->addLineTable(); - LT.addStandardOpcode(DW_LNS_copy, {}); - LT.addStandardOpcode(DW_LNS_const_add_pc, {}); - LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); - DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue(); - // Set the total length to 1 higher than the actual length. - ++Prologue.TotalLength; - LT.setPrologue(Prologue); - - generate(); - - auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 1, *Context, - nullptr, RecordRecoverable); - checkError("line table program with offset 0x00000001 has length 0x00000034 " - "but only 0x00000033 bytes are available", - std::move(Recoverable)); - ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); - EXPECT_EQ((*ExpectedLineTable)->Rows.size(), 2u); - EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u); -} - -TEST_F(DebugLineBasicFixture, ErrorForMismatchedAddressSize) { - if (!setupGenerator(4, 8)) - return; - - LineTable < = Gen->addLineTable(); - // The line data extractor expects size 8 (Quad) addresses. - uint64_t Addr1 = 0x11223344; - LT.addExtendedOpcode(5, DW_LNE_set_address, {{Addr1, LineTable::Long}}); - LT.addStandardOpcode(DW_LNS_copy, {}); - // Show that the expected address size is unchanged, so later valid lines - // don't cause a problem. - uint64_t Addr2 = 0x1122334455667788; - LT.addExtendedOpcode(9, DW_LNE_set_address, {{Addr2, LineTable::Quad}}); - LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); - - generate(); - - auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, - nullptr, RecordRecoverable); - checkError( - "mismatching address size at offset 0x00000030 expected 0x08 found 0x04", - std::move(Recoverable)); - ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); - ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 2u); - EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u); - EXPECT_EQ((*ExpectedLineTable)->Rows[0].Address.Address, Addr1); - EXPECT_EQ((*ExpectedLineTable)->Rows[1].Address.Address, Addr2); -} - -TEST_F(DebugLineBasicFixture, - ErrorForMismatchedAddressSizeUnsetInitialAddress) { - if (!setupGenerator(4, 0)) - return; - - LineTable < = Gen->addLineTable(); - uint64_t Addr1 = 0x11223344; - LT.addExtendedOpcode(5, DW_LNE_set_address, {{Addr1, LineTable::Long}}); - LT.addStandardOpcode(DW_LNS_copy, {}); - uint64_t Addr2 = 0x1122334455667788; - LT.addExtendedOpcode(9, DW_LNE_set_address, {{Addr2, LineTable::Quad}}); - LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); - - generate(); - - auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, - nullptr, RecordRecoverable); - checkError( - "mismatching address size at offset 0x00000038 expected 0x04 found 0x08", - std::move(Recoverable)); - ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); - ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 2u); - EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u); - EXPECT_EQ((*ExpectedLineTable)->Rows[0].Address.Address, Addr1); - EXPECT_EQ((*ExpectedLineTable)->Rows[1].Address.Address, Addr2); -} - -TEST_F(DebugLineBasicFixture, CallbackUsedForUnterminatedSequence) { - if (!setupGenerator()) - return; - - LineTable < = Gen->addLineTable(); - LT.addExtendedOpcode(9, DW_LNE_set_address, - {{0x1122334455667788, LineTable::Quad}}); - LT.addStandardOpcode(DW_LNS_copy, {}); - LT.addByte(0xaa); - LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); - LT.addExtendedOpcode(9, DW_LNE_set_address, - {{0x99aabbccddeeff00, LineTable::Quad}}); - LT.addStandardOpcode(DW_LNS_copy, {}); - LT.addByte(0xbb); - LT.addByte(0xcc); - - generate(); - - auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, - nullptr, RecordRecoverable); - checkError("last sequence in debug line table at offset 0x00000000 is not " - "terminated", - std::move(Recoverable)); - ASSERT_TRUE(ExpectedLineTable.operator bool()); - EXPECT_EQ((*ExpectedLineTable)->Rows.size(), 6u); - // The unterminated sequence is not added to the sequence list. - EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u); -} - -TEST_F(DebugLineBasicFixture, ParserParsesCorrectly) { - if (!setupGenerator()) - return; - - DWARFDebugLine::SectionParser Parser = setupParser(); - - EXPECT_EQ(Parser.getOffset(), 0u); - ASSERT_FALSE(Parser.done()); - - DWARFDebugLine::LineTable Parsed = - Parser.parseNext(RecordRecoverable, RecordUnrecoverable); - checkDefaultPrologue(4, DWARF32, Parsed.Prologue, 16); - EXPECT_EQ(Parsed.Sequences.size(), 1u); - EXPECT_EQ(Parser.getOffset(), 62u); - ASSERT_FALSE(Parser.done()); - - DWARFDebugLine::LineTable Parsed2 = - Parser.parseNext(RecordRecoverable, RecordUnrecoverable); - checkDefaultPrologue(4, DWARF64, Parsed2.Prologue, 16); - EXPECT_EQ(Parsed2.Sequences.size(), 1u); - EXPECT_EQ(Parser.getOffset(), 136u); - EXPECT_TRUE(Parser.done()); - - EXPECT_FALSE(Recoverable); - EXPECT_FALSE(Unrecoverable); -} - -TEST_F(DebugLineBasicFixture, ParserSkipsCorrectly) { - if (!setupGenerator()) - return; - - DWARFDebugLine::SectionParser Parser = setupParser(); - - EXPECT_EQ(Parser.getOffset(), 0u); - ASSERT_FALSE(Parser.done()); - - Parser.skip(RecordRecoverable, RecordUnrecoverable); - EXPECT_EQ(Parser.getOffset(), 62u); - ASSERT_FALSE(Parser.done()); - - Parser.skip(RecordRecoverable, RecordUnrecoverable); - EXPECT_EQ(Parser.getOffset(), 136u); - EXPECT_TRUE(Parser.done()); - - EXPECT_FALSE(Recoverable); - EXPECT_FALSE(Unrecoverable); -} - -TEST_F(DebugLineBasicFixture, ParserAlwaysDoneForEmptySection) { - if (!setupGenerator()) - return; - - generate(); - DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); - - EXPECT_TRUE(Parser.done()); -} - -TEST_F(DebugLineBasicFixture, ParserMovesToEndForBadLengthWhenParsing) { - if (!setupGenerator()) - return; - - LineTable < = Gen->addLineTable(); - LT.setCustomPrologue({{0xfffffff0, LineTable::Long}}); - Gen->addLineTable(); - generate(); - - DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); - Parser.parseNext(RecordRecoverable, RecordUnrecoverable); - - EXPECT_EQ(Parser.getOffset(), 4u); - EXPECT_TRUE(Parser.done()); - EXPECT_FALSE(Recoverable); - - checkError("parsing line table prologue at offset 0x00000000 unsupported " - "reserved unit length found of value 0xfffffff0", - std::move(Unrecoverable)); -} - -TEST_F(DebugLineBasicFixture, ParserMovesToEndForBadLengthWhenSkipping) { - if (!setupGenerator()) - return; - - LineTable < = Gen->addLineTable(); - LT.setCustomPrologue({{0xfffffff0, LineTable::Long}}); - Gen->addLineTable(); - generate(); - - DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); - Parser.skip(RecordRecoverable, RecordUnrecoverable); - - EXPECT_EQ(Parser.getOffset(), 4u); - EXPECT_TRUE(Parser.done()); - EXPECT_FALSE(Recoverable); - - checkError("parsing line table prologue at offset 0x00000000 unsupported " - "reserved unit length found of value 0xfffffff0", - std::move(Unrecoverable)); -} - -TEST_F(DebugLineBasicFixture, ParserReportsFirstErrorInEachTableWhenParsing) { - if (!setupGenerator()) - return; - - LineTable < = Gen->addLineTable(DWARF32); - LT.setCustomPrologue({{2, LineTable::Long}, {0, LineTable::Half}}); - LineTable <2 = Gen->addLineTable(DWARF32); - LT2.setCustomPrologue({{2, LineTable::Long}, {1, LineTable::Half}}); - generate(); - - DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); - Parser.parseNext(RecordRecoverable, RecordUnrecoverable); - ASSERT_FALSE(Parser.done()); - Parser.parseNext(RecordRecoverable, RecordUnrecoverable); - - EXPECT_TRUE(Parser.done()); - EXPECT_FALSE(Recoverable); - - checkError({"parsing line table prologue at offset 0x00000000 found " - "unsupported version 0x00", - "parsing line table prologue at offset 0x00000006 found " - "unsupported version 0x01"}, - std::move(Unrecoverable)); -} - -TEST_F(DebugLineBasicFixture, ParserReportsNonPrologueProblemsWhenParsing) { - if (!setupGenerator()) - return; - - LineTable < = Gen->addLineTable(DWARF32); - LT.addExtendedOpcode(0x42, DW_LNE_end_sequence, {}); - LineTable <2 = Gen->addLineTable(DWARF32); - LT2.addExtendedOpcode(9, DW_LNE_set_address, - {{0x1234567890abcdef, LineTable::Quad}}); - LT2.addStandardOpcode(DW_LNS_copy, {}); - LT2.addByte(0xbb); - generate(); - - DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); - Parser.parseNext(RecordRecoverable, RecordUnrecoverable); - EXPECT_FALSE(Unrecoverable); - ASSERT_FALSE(Parser.done()); - checkError( - "unexpected line op length at offset 0x00000030 expected 0x42 found 0x01", - std::move(Recoverable)); - - // Reset the error state so that it does not confuse the next set of checks. - Unrecoverable = Error::success(); - Parser.parseNext(RecordRecoverable, RecordUnrecoverable); - - EXPECT_TRUE(Parser.done()); - checkError("last sequence in debug line table at offset 0x00000031 is not " - "terminated", - std::move(Recoverable)); - EXPECT_FALSE(Unrecoverable); -} - -TEST_F(DebugLineBasicFixture, - ParserReportsPrologueErrorsInEachTableWhenSkipping) { - if (!setupGenerator()) - return; - - LineTable < = Gen->addLineTable(DWARF32); - LT.setCustomPrologue({{2, LineTable::Long}, {0, LineTable::Half}}); - LineTable <2 = Gen->addLineTable(DWARF32); - LT2.setCustomPrologue({{2, LineTable::Long}, {1, LineTable::Half}}); - generate(); - - DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); - Parser.skip(RecordRecoverable, RecordUnrecoverable); - ASSERT_FALSE(Parser.done()); - Parser.skip(RecordRecoverable, RecordUnrecoverable); - - EXPECT_TRUE(Parser.done()); - EXPECT_FALSE(Recoverable); - - checkError({"parsing line table prologue at offset 0x00000000 found " - "unsupported version 0x00", - "parsing line table prologue at offset 0x00000006 found " - "unsupported version 0x01"}, - std::move(Unrecoverable)); -} - -TEST_F(DebugLineBasicFixture, ParserIgnoresNonPrologueErrorsWhenSkipping) { - if (!setupGenerator()) - return; - - LineTable < = Gen->addLineTable(DWARF32); - LT.addExtendedOpcode(42, DW_LNE_end_sequence, {}); - generate(); - - DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); - Parser.skip(RecordRecoverable, RecordUnrecoverable); - - EXPECT_TRUE(Parser.done()); - EXPECT_FALSE(Recoverable); - EXPECT_FALSE(Unrecoverable); -} - -TEST_F(DebugLineBasicFixture, ParserPrintsStandardOpcodesWhenRequested) { - if (!setupGenerator()) - return; - - using ValLen = dwarfgen::LineTable::ValueAndLength; - LineTable < = Gen->addLineTable(DWARF32); - LT.addStandardOpcode(DW_LNS_copy, {}); - LT.addStandardOpcode(DW_LNS_advance_pc, {ValLen{11, LineTable::ULEB}}); - LT.addStandardOpcode(DW_LNS_advance_line, {ValLen{22, LineTable::SLEB}}); - LT.addStandardOpcode(DW_LNS_set_file, {ValLen{33, LineTable::ULEB}}); - LT.addStandardOpcode(DW_LNS_set_column, {ValLen{44, LineTable::ULEB}}); - LT.addStandardOpcode(DW_LNS_negate_stmt, {}); - LT.addStandardOpcode(DW_LNS_set_basic_block, {}); - LT.addStandardOpcode(DW_LNS_const_add_pc, {}); - LT.addStandardOpcode(DW_LNS_fixed_advance_pc, {ValLen{55, LineTable::Half}}); - LT.addStandardOpcode(DW_LNS_set_prologue_end, {}); - LT.addStandardOpcode(DW_LNS_set_epilogue_begin, {}); - LT.addStandardOpcode(DW_LNS_set_isa, {ValLen{66, LineTable::ULEB}}); - LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); - generate(); - - DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); - std::string Output; - raw_string_ostream OS(Output); - Parser.parseNext(RecordRecoverable, RecordUnrecoverable, &OS); - OS.flush(); - - EXPECT_FALSE(Recoverable); - EXPECT_FALSE(Unrecoverable); - auto InOutput = [&Output](char const *Str) { - return Output.find(Str) != std::string::npos; - }; - EXPECT_TRUE(InOutput("0x0000002e: 01 DW_LNS_copy\n")) << Output; - EXPECT_TRUE(InOutput("0x0000002f: 02 DW_LNS_advance_pc (11)\n")) << Output; - // FIXME: The value printed after DW_LNS_advance_line is currently the result - // of the advance, but it should be the value being advanced by. See - // https://bugs.llvm.org/show_bug.cgi?id=44261 for details. - EXPECT_TRUE(InOutput("0x00000031: 03 DW_LNS_advance_line (23)\n")) << Output; - EXPECT_TRUE(InOutput("0x00000033: 04 DW_LNS_set_file (33)\n")) << Output; - EXPECT_TRUE(InOutput("0x00000035: 05 DW_LNS_set_column (44)\n")) << Output; - EXPECT_TRUE(InOutput("0x00000037: 06 DW_LNS_negate_stmt\n")) << Output; - EXPECT_TRUE(InOutput("0x00000038: 07 DW_LNS_set_basic_block\n")) << Output; - EXPECT_TRUE( - InOutput("0x00000039: 08 DW_LNS_const_add_pc (0x0000000000000011)\n")) - << Output; - EXPECT_TRUE(InOutput("0x0000003a: 09 DW_LNS_fixed_advance_pc (0x0037)\n")) - << Output; - EXPECT_TRUE(InOutput("0x0000003d: 0a DW_LNS_set_prologue_end\n")) << Output; - EXPECT_TRUE(InOutput("0x0000003e: 0b DW_LNS_set_epilogue_begin\n")) << Output; - EXPECT_TRUE(InOutput("0x0000003f: 0c DW_LNS_set_isa (66)\n")) << Output; -} - -} // end anonymous namespace +//===- DWARFDebugLineTest.cpp ---------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "DwarfGenerator.h" +#include "DwarfUtils.h" +#include "llvm/DebugInfo/DWARF/DWARFContext.h" +#include "llvm/DebugInfo/DWARF/DWARFDebugLine.h" +#include "llvm/Object/ObjectFile.h" +#include "llvm/Testing/Support/Error.h" +#include "gtest/gtest.h" + +using namespace llvm; +using namespace dwarf; +using namespace dwarfgen; +using namespace object; +using namespace utils; +using namespace testing; + +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()); + return true; + } + + void generate() { + Context = createContext(); + assert(Context != nullptr && "test state is not valid"); + const DWARFObject &Obj = Context->getDWARFObj(); + uint8_t TargetAddrSize = AddressSize == 0 ? 8 : AddressSize; + LineData = DWARFDataExtractor( + Obj, Obj.getLineSection(), + getDefaultTargetTripleForAddrSize(TargetAddrSize).isLittleEndian(), + AddressSize); + } + + std::unique_ptr createContext() { + if (!Gen) + return nullptr; + StringRef FileBytes = Gen->generate(); + MemoryBufferRef FileBuffer(FileBytes, "dwarf"); + auto Obj = object::ObjectFile::createObjectFile(FileBuffer); + if (Obj) + return DWARFContext::create(**Obj); + return nullptr; + } + + DWARFDebugLine::SectionParser setupParser() { + LineTable < = Gen->addLineTable(DWARF32); + LT.addExtendedOpcode(9, DW_LNE_set_address, {{0xadd4e55, LineTable::Quad}}); + LT.addStandardOpcode(DW_LNS_copy, {}); + LT.addByte(0xaa); + LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); + + LineTable <2 = Gen->addLineTable(DWARF64); + LT2.addExtendedOpcode(9, DW_LNE_set_address, + {{0x11223344, LineTable::Quad}}); + LT2.addStandardOpcode(DW_LNS_copy, {}); + LT2.addByte(0xbb); + LT2.addExtendedOpcode(1, DW_LNE_end_sequence, {}); + + generate(); + + return DWARFDebugLine::SectionParser(LineData, *Context, CUs, TUs); + } + + void recordRecoverable(Error Err) { + Recoverable = joinErrors(std::move(Recoverable), std::move(Err)); + } + void recordUnrecoverable(Error Err) { + Unrecoverable = joinErrors(std::move(Unrecoverable), std::move(Err)); + } + + void checkError(ArrayRef ExpectedMsgs, Error Err) { + ASSERT_TRUE(Err.operator bool()); + size_t WhichMsg = 0; + Error Remaining = + handleErrors(std::move(Err), [&](const ErrorInfoBase &Actual) { + ASSERT_LT(WhichMsg, ExpectedMsgs.size()); + // Use .str(), because googletest doesn't visualise a StringRef + // properly. + EXPECT_EQ(Actual.message(), ExpectedMsgs[WhichMsg++].str()); + }); + EXPECT_EQ(WhichMsg, ExpectedMsgs.size()); + EXPECT_FALSE(Remaining); + } + + void checkError(StringRef ExpectedMsg, Error Err) { + checkError(ArrayRef{ExpectedMsg}, std::move(Err)); + } + + void checkGetOrParseLineTableEmitsFatalError(StringRef ExpectedMsg, + uint64_t Offset = 0) { + auto ExpectedLineTable = Line.getOrParseLineTable( + LineData, Offset, *Context, nullptr, RecordRecoverable); + EXPECT_FALSE(ExpectedLineTable); + EXPECT_FALSE(Recoverable); + + checkError(ExpectedMsg, ExpectedLineTable.takeError()); + } + + void checkGetOrParseLineTableEmitsFatalError(ArrayRef ExpectedMsgs, + uint64_t Offset = 0) { + auto ExpectedLineTable = Line.getOrParseLineTable( + LineData, Offset, *Context, nullptr, RecordRecoverable); + EXPECT_FALSE(ExpectedLineTable); + EXPECT_FALSE(Recoverable); + + checkError(ExpectedMsgs, ExpectedLineTable.takeError()); + } + + uint8_t AddressSize; + std::unique_ptr Gen; + std::unique_ptr Context; + DWARFDataExtractor LineData; + DWARFDebugLine Line; + Error Recoverable; + std::function RecordRecoverable; + Error Unrecoverable; + std::function RecordUnrecoverable; + + SmallVector, 2> CUs; + SmallVector, 2> TUs; +}; + +// Fixtures must derive from "Test", but parameterised fixtures from +// "TestWithParam". It does not seem possible to inherit from both, so we share +// the common state in a separate class, inherited by the two fixture classes. +struct DebugLineBasicFixture : public Test, public CommonFixture {}; + +struct DebugLineParameterisedFixture + : public TestWithParam>, + public CommonFixture { + void SetUp() { std::tie(Version, Format) = GetParam(); } + + uint16_t Version; + DwarfFormat Format; +}; + +void checkDefaultPrologue(uint16_t Version, DwarfFormat Format, + DWARFDebugLine::Prologue Prologue, + uint64_t BodyLength) { + // Check version specific fields and values. + uint64_t UnitLength; + uint64_t PrologueLength; + switch (Version) { + case 4: + PrologueLength = 36; + UnitLength = PrologueLength + 2; + EXPECT_EQ(Prologue.MaxOpsPerInst, 1u); + break; + case 2: + case 3: + PrologueLength = 35; + UnitLength = PrologueLength + 2; + break; + case 5: + PrologueLength = 39; + UnitLength = PrologueLength + 4; + EXPECT_EQ(Prologue.getAddressSize(), 8u); + EXPECT_EQ(Prologue.SegSelectorSize, 0u); + break; + default: + llvm_unreachable("unsupported DWARF version"); + } + UnitLength += BodyLength + (Format == DWARF32 ? 4 : 8); + + EXPECT_EQ(Prologue.TotalLength, UnitLength); + EXPECT_EQ(Prologue.PrologueLength, PrologueLength); + EXPECT_EQ(Prologue.MinInstLength, 1u); + EXPECT_EQ(Prologue.DefaultIsStmt, 1u); + EXPECT_EQ(Prologue.LineBase, -5); + EXPECT_EQ(Prologue.LineRange, 14u); + EXPECT_EQ(Prologue.OpcodeBase, 13u); + std::vector ExpectedLengths = {0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1}; + EXPECT_EQ(Prologue.StandardOpcodeLengths, ExpectedLengths); + ASSERT_EQ(Prologue.IncludeDirectories.size(), 1u); + ASSERT_EQ(Prologue.IncludeDirectories[0].getForm(), DW_FORM_string); + EXPECT_STREQ(*Prologue.IncludeDirectories[0].getAsCString(), "a dir"); + ASSERT_EQ(Prologue.FileNames.size(), 1u); + ASSERT_EQ(Prologue.FileNames[0].Name.getForm(), DW_FORM_string); + EXPECT_STREQ(*Prologue.FileNames[0].Name.getAsCString(), "a file"); +} + +TEST_F(DebugLineBasicFixture, GetOrParseLineTableAtInvalidOffset) { + if (!setupGenerator()) + return; + generate(); + + checkGetOrParseLineTableEmitsFatalError( + "offset 0x00000000 is not a valid debug line section offset", 0); + // Repeat to show that an error is reported each time. + checkGetOrParseLineTableEmitsFatalError( + "offset 0x00000000 is not a valid debug line section offset", 0); + // Show that an error is reported for later offsets too. + checkGetOrParseLineTableEmitsFatalError( + "offset 0x00000001 is not a valid debug line section offset", 1); +} + +TEST_F(DebugLineBasicFixture, GetOrParseLineTableAtInvalidOffsetAfterData) { + if (!setupGenerator()) + return; + + LineTable < = Gen->addLineTable(); + 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 < = 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 < = Gen->addLineTable(Format); + LT.addExtendedOpcode(9, DW_LNE_set_address, {{0xadd4e55, LineTable::Quad}}); + LT.addStandardOpcode(DW_LNS_copy, {}); + LT.addByte(0xaa); + LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); + + LineTable <2 = Gen->addLineTable(Format); + LT2.addExtendedOpcode(9, DW_LNE_set_address, {{0x11223344, LineTable::Quad}}); + LT2.addStandardOpcode(DW_LNS_copy, {}); + LT2.addByte(0xbb); + LT2.addExtendedOpcode(1, DW_LNE_end_sequence, {}); + LT2.addExtendedOpcode(9, DW_LNE_set_address, {{0x55667788, LineTable::Quad}}); + LT2.addStandardOpcode(DW_LNS_copy, {}); + LT2.addByte(0xcc); + LT2.addExtendedOpcode(1, DW_LNE_end_sequence, {}); + + generate(); + + auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, + nullptr, RecordRecoverable); + ASSERT_TRUE(ExpectedLineTable.operator bool()); + EXPECT_FALSE(Recoverable); + const DWARFDebugLine::LineTable *Expected = *ExpectedLineTable; + checkDefaultPrologue(Version, Format, Expected->Prologue, 16); + EXPECT_EQ(Expected->Sequences.size(), 1u); + + uint64_t SecondOffset = + Expected->Prologue.sizeofTotalLength() + Expected->Prologue.TotalLength; + Recoverable = Error::success(); + auto ExpectedLineTable2 = Line.getOrParseLineTable( + LineData, SecondOffset, *Context, nullptr, RecordRecoverable); + ASSERT_TRUE(ExpectedLineTable2.operator bool()); + EXPECT_FALSE(Recoverable); + const DWARFDebugLine::LineTable *Expected2 = *ExpectedLineTable2; + checkDefaultPrologue(Version, Format, Expected2->Prologue, 32); + EXPECT_EQ(Expected2->Sequences.size(), 2u); + + EXPECT_NE(Expected, Expected2); + + // Check that if the same offset is requested, the exact same pointer is + // returned. + Recoverable = Error::success(); + auto ExpectedLineTable3 = Line.getOrParseLineTable( + LineData, 0, *Context, nullptr, RecordRecoverable); + ASSERT_TRUE(ExpectedLineTable3.operator bool()); + EXPECT_FALSE(Recoverable); + EXPECT_EQ(Expected, *ExpectedLineTable3); + + Recoverable = Error::success(); + auto ExpectedLineTable4 = Line.getOrParseLineTable( + LineData, SecondOffset, *Context, nullptr, RecordRecoverable); + ASSERT_TRUE(ExpectedLineTable4.operator bool()); + EXPECT_FALSE(Recoverable); + EXPECT_EQ(Expected2, *ExpectedLineTable4); + + // TODO: Add tests that show that the body of the programs have been read + // correctly. +} + +TEST_F(DebugLineBasicFixture, ErrorForReservedLength) { + if (!setupGenerator()) + return; + + LineTable < = Gen->addLineTable(); + LT.setCustomPrologue({{0xfffffff0, LineTable::Long}}); + + generate(); + + checkGetOrParseLineTableEmitsFatalError( + "parsing line table prologue at offset 0x00000000 unsupported reserved " + "unit length found of value 0xfffffff0"); +} + +TEST_F(DebugLineBasicFixture, ErrorForLowVersion) { + if (!setupGenerator()) + return; + + LineTable < = Gen->addLineTable(); + LT.setCustomPrologue( + {{LineTable::Half, LineTable::Long}, {1, LineTable::Half}}); + + generate(); + + checkGetOrParseLineTableEmitsFatalError( + "parsing line table prologue at offset " + "0x00000000 found unsupported version " + "0x01"); +} + +TEST_F(DebugLineBasicFixture, ErrorForInvalidV5IncludeDirTable) { + if (!setupGenerator(5)) + return; + + LineTable < = Gen->addLineTable(); + LT.setCustomPrologue({ + {19, LineTable::Long}, // unit length + {5, LineTable::Half}, // version + {8, LineTable::Byte}, // addr size + {0, LineTable::Byte}, // segment selector size + {11, LineTable::Long}, // prologue length + {1, LineTable::Byte}, // min instruction length + {1, LineTable::Byte}, // max ops per instruction + {1, LineTable::Byte}, // default is_stmt + {0, LineTable::Byte}, // line base + {14, LineTable::Byte}, // line range + {2, LineTable::Byte}, // opcode base (small to reduce the amount of + // setup required). + {0, LineTable::Byte}, // standard opcode lengths + {0, LineTable::Byte}, // directory entry format count (should not be + // zero). + {0, LineTable::ULEB}, // directories count + {0, LineTable::Byte}, // file name entry format count + {0, LineTable::ULEB} // file name entry count + }); + + generate(); + + auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, + nullptr, RecordRecoverable); + EXPECT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); + + checkError( + {"parsing line table prologue at 0x00000000 found an invalid directory " + "or file table description at 0x00000014", + "failed to parse entry content descriptions because no path was found"}, + std::move(Recoverable)); +} + +TEST_P(DebugLineParameterisedFixture, ErrorForTooLargePrologueLength) { + if (!setupGenerator(Version)) + return; + + SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " + + (Format == DWARF64 ? "DWARF64" : "DWARF32")); + + LineTable < = Gen->addLineTable(Format); + DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue(); + ++Prologue.PrologueLength; + LT.setPrologue(Prologue); + + generate(); + + auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, + nullptr, RecordRecoverable); + ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); + DWARFDebugLine::LineTable Result(**ExpectedLineTable); + // Undo the earlier modification so that it can be compared against a + // "default" prologue. + --Result.Prologue.PrologueLength; + checkDefaultPrologue(Version, Format, Result.Prologue, 0); + + uint64_t ExpectedEnd = + Prologue.TotalLength + 1 + Prologue.sizeofTotalLength(); + checkError( + (Twine("parsing line table prologue at 0x00000000 should have ended at " + "0x000000") + + Twine::utohexstr(ExpectedEnd) + " but it ended at 0x000000" + + Twine::utohexstr(ExpectedEnd - 1)) + .str(), + std::move(Recoverable)); +} + +TEST_P(DebugLineParameterisedFixture, ErrorForTooShortPrologueLength) { + if (!setupGenerator(Version)) + return; + + SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " + + (Format == DWARF64 ? "DWARF64" : "DWARF32")); + + LineTable < = Gen->addLineTable(Format); + DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue(); + // FIXME: Ideally, we'd test for 1 less than expected, but the code does not + // currently fail if missing only the terminator of a v2-4 file table. + if (Version < 5) + Prologue.PrologueLength -= 2; + else + Prologue.PrologueLength -= 1; + LT.setPrologue(Prologue); + + generate(); + + auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, + nullptr, RecordRecoverable); + ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); + DWARFDebugLine::LineTable Result(**ExpectedLineTable); + // Undo the earlier modification so that it can be compared against a + // "default" prologue. + if (Version < 5) + Result.Prologue.PrologueLength += 2; + else + Result.Prologue.PrologueLength += 1; + checkDefaultPrologue(Version, Format, Result.Prologue, 0); + + uint64_t ExpectedEnd = + Prologue.TotalLength - 1 + Prologue.sizeofTotalLength(); + if (Version < 5) + --ExpectedEnd; + checkError( + (Twine("parsing line table prologue at 0x00000000 should have ended at " + "0x000000") + + Twine::utohexstr(ExpectedEnd) + " but it ended at 0x000000" + + Twine::utohexstr(ExpectedEnd + 1)) + .str(), + std::move(Recoverable)); +} + +INSTANTIATE_TEST_CASE_P( + LineTableTestParams, DebugLineParameterisedFixture, + Values(std::make_pair( + 2, DWARF32), // Test lower-bound of v2-3 fields and DWARF32. + std::make_pair(3, DWARF32), // Test upper-bound of v2-3 fields. + std::make_pair(4, DWARF64), // Test v4 fields and DWARF64. + std::make_pair(5, DWARF32), std::make_pair(5, DWARF64)), ); + +TEST_F(DebugLineBasicFixture, ErrorForExtendedOpcodeLengthSmallerThanExpected) { + if (!setupGenerator()) + return; + + LineTable < = Gen->addLineTable(); + LT.addByte(0xaa); + // The Length should be 1 + sizeof(ULEB) for a set discriminator opcode. + // The operand will be read for both the discriminator opcode and then parsed + // again as DW_LNS_negate_stmt, to respect the claimed length. + LT.addExtendedOpcode(1, DW_LNE_set_discriminator, + {{DW_LNS_negate_stmt, LineTable::ULEB}}); + LT.addByte(0xbb); + LT.addStandardOpcode(DW_LNS_const_add_pc, {}); + LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); + + generate(); + + auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, + nullptr, RecordRecoverable); + checkError( + "unexpected line op length at offset 0x00000031 expected 0x01 found 0x02", + std::move(Recoverable)); + ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); + ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 3u); + EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u); + EXPECT_EQ((*ExpectedLineTable)->Rows[1].IsStmt, 0u); + EXPECT_EQ((*ExpectedLineTable)->Rows[1].Discriminator, DW_LNS_negate_stmt); +} + +TEST_F(DebugLineBasicFixture, ErrorForExtendedOpcodeLengthLargerThanExpected) { + if (!setupGenerator()) + return; + + LineTable < = Gen->addLineTable(); + LT.addByte(0xaa); + LT.addStandardOpcode(DW_LNS_const_add_pc, {}); + // The Length should be 1 for an end sequence opcode. + LT.addExtendedOpcode(2, DW_LNE_end_sequence, {}); + // The negate statement opcode will be skipped. + LT.addStandardOpcode(DW_LNS_negate_stmt, {}); + LT.addByte(0xbb); + LT.addStandardOpcode(DW_LNS_const_add_pc, {}); + LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); + + generate(); + + auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, + nullptr, RecordRecoverable); + checkError( + "unexpected line op length at offset 0x00000032 expected 0x02 found 0x01", + std::move(Recoverable)); + ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); + ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 4u); + EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 2u); + ASSERT_EQ((*ExpectedLineTable)->Sequences[1].FirstRowIndex, 2u); + EXPECT_EQ((*ExpectedLineTable)->Rows[2].IsStmt, 1u); +} + +TEST_F(DebugLineBasicFixture, ErrorForUnitLengthTooLarge) { + if (!setupGenerator()) + return; + + LineTable &Padding = Gen->addLineTable(); + // Add some padding to show that a non-zero offset is handled correctly. + Padding.setCustomPrologue({{0, LineTable::Byte}}); + LineTable < = Gen->addLineTable(); + LT.addStandardOpcode(DW_LNS_copy, {}); + LT.addStandardOpcode(DW_LNS_const_add_pc, {}); + LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); + DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue(); + // Set the total length to 1 higher than the actual length. + ++Prologue.TotalLength; + LT.setPrologue(Prologue); + + generate(); + + auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 1, *Context, + nullptr, RecordRecoverable); + checkError("line table program with offset 0x00000001 has length 0x00000034 " + "but only 0x00000033 bytes are available", + std::move(Recoverable)); + ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); + EXPECT_EQ((*ExpectedLineTable)->Rows.size(), 2u); + EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u); +} + +TEST_F(DebugLineBasicFixture, ErrorForMismatchedAddressSize) { + if (!setupGenerator(4, 8)) + return; + + LineTable < = Gen->addLineTable(); + // The line data extractor expects size 8 (Quad) addresses. + uint64_t Addr1 = 0x11223344; + LT.addExtendedOpcode(5, DW_LNE_set_address, {{Addr1, LineTable::Long}}); + LT.addStandardOpcode(DW_LNS_copy, {}); + // Show that the expected address size is unchanged, so later valid lines + // don't cause a problem. + uint64_t Addr2 = 0x1122334455667788; + LT.addExtendedOpcode(9, DW_LNE_set_address, {{Addr2, LineTable::Quad}}); + LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); + + generate(); + + auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, + nullptr, RecordRecoverable); + checkError( + "mismatching address size at offset 0x00000030 expected 0x08 found 0x04", + std::move(Recoverable)); + ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); + ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 2u); + EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u); + EXPECT_EQ((*ExpectedLineTable)->Rows[0].Address.Address, Addr1); + EXPECT_EQ((*ExpectedLineTable)->Rows[1].Address.Address, Addr2); +} + +TEST_F(DebugLineBasicFixture, + ErrorForMismatchedAddressSizeUnsetInitialAddress) { + if (!setupGenerator(4, 0)) + return; + + LineTable < = Gen->addLineTable(); + uint64_t Addr1 = 0x11223344; + LT.addExtendedOpcode(5, DW_LNE_set_address, {{Addr1, LineTable::Long}}); + LT.addStandardOpcode(DW_LNS_copy, {}); + uint64_t Addr2 = 0x1122334455667788; + LT.addExtendedOpcode(9, DW_LNE_set_address, {{Addr2, LineTable::Quad}}); + LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); + + generate(); + + auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, + nullptr, RecordRecoverable); + checkError( + "mismatching address size at offset 0x00000038 expected 0x04 found 0x08", + std::move(Recoverable)); + ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded()); + ASSERT_EQ((*ExpectedLineTable)->Rows.size(), 2u); + EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u); + EXPECT_EQ((*ExpectedLineTable)->Rows[0].Address.Address, Addr1); + EXPECT_EQ((*ExpectedLineTable)->Rows[1].Address.Address, Addr2); +} + +TEST_F(DebugLineBasicFixture, CallbackUsedForUnterminatedSequence) { + if (!setupGenerator()) + return; + + LineTable < = Gen->addLineTable(); + LT.addExtendedOpcode(9, DW_LNE_set_address, + {{0x1122334455667788, LineTable::Quad}}); + LT.addStandardOpcode(DW_LNS_copy, {}); + LT.addByte(0xaa); + LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); + LT.addExtendedOpcode(9, DW_LNE_set_address, + {{0x99aabbccddeeff00, LineTable::Quad}}); + LT.addStandardOpcode(DW_LNS_copy, {}); + LT.addByte(0xbb); + LT.addByte(0xcc); + + generate(); + + auto ExpectedLineTable = Line.getOrParseLineTable(LineData, 0, *Context, + nullptr, RecordRecoverable); + checkError("last sequence in debug line table at offset 0x00000000 is not " + "terminated", + std::move(Recoverable)); + ASSERT_TRUE(ExpectedLineTable.operator bool()); + EXPECT_EQ((*ExpectedLineTable)->Rows.size(), 6u); + // The unterminated sequence is not added to the sequence list. + EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u); +} + +TEST_F(DebugLineBasicFixture, ParserParsesCorrectly) { + if (!setupGenerator()) + return; + + DWARFDebugLine::SectionParser Parser = setupParser(); + + EXPECT_EQ(Parser.getOffset(), 0u); + ASSERT_FALSE(Parser.done()); + + DWARFDebugLine::LineTable Parsed = + Parser.parseNext(RecordRecoverable, RecordUnrecoverable); + checkDefaultPrologue(4, DWARF32, Parsed.Prologue, 16); + EXPECT_EQ(Parsed.Sequences.size(), 1u); + EXPECT_EQ(Parser.getOffset(), 62u); + ASSERT_FALSE(Parser.done()); + + DWARFDebugLine::LineTable Parsed2 = + Parser.parseNext(RecordRecoverable, RecordUnrecoverable); + checkDefaultPrologue(4, DWARF64, Parsed2.Prologue, 16); + EXPECT_EQ(Parsed2.Sequences.size(), 1u); + EXPECT_EQ(Parser.getOffset(), 136u); + EXPECT_TRUE(Parser.done()); + + EXPECT_FALSE(Recoverable); + EXPECT_FALSE(Unrecoverable); +} + +TEST_F(DebugLineBasicFixture, ParserSkipsCorrectly) { + if (!setupGenerator()) + return; + + DWARFDebugLine::SectionParser Parser = setupParser(); + + EXPECT_EQ(Parser.getOffset(), 0u); + ASSERT_FALSE(Parser.done()); + + Parser.skip(RecordRecoverable, RecordUnrecoverable); + EXPECT_EQ(Parser.getOffset(), 62u); + ASSERT_FALSE(Parser.done()); + + Parser.skip(RecordRecoverable, RecordUnrecoverable); + EXPECT_EQ(Parser.getOffset(), 136u); + EXPECT_TRUE(Parser.done()); + + EXPECT_FALSE(Recoverable); + EXPECT_FALSE(Unrecoverable); +} + +TEST_F(DebugLineBasicFixture, ParserAlwaysDoneForEmptySection) { + if (!setupGenerator()) + return; + + generate(); + DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); + + EXPECT_TRUE(Parser.done()); +} + +TEST_F(DebugLineBasicFixture, ParserMovesToEndForBadLengthWhenParsing) { + if (!setupGenerator()) + return; + + LineTable < = Gen->addLineTable(); + LT.setCustomPrologue({{0xfffffff0, LineTable::Long}}); + Gen->addLineTable(); + generate(); + + DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); + Parser.parseNext(RecordRecoverable, RecordUnrecoverable); + + EXPECT_EQ(Parser.getOffset(), 4u); + EXPECT_TRUE(Parser.done()); + EXPECT_FALSE(Recoverable); + + checkError("parsing line table prologue at offset 0x00000000 unsupported " + "reserved unit length found of value 0xfffffff0", + std::move(Unrecoverable)); +} + +TEST_F(DebugLineBasicFixture, ParserMovesToEndForBadLengthWhenSkipping) { + if (!setupGenerator()) + return; + + LineTable < = Gen->addLineTable(); + LT.setCustomPrologue({{0xfffffff0, LineTable::Long}}); + Gen->addLineTable(); + generate(); + + DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); + Parser.skip(RecordRecoverable, RecordUnrecoverable); + + EXPECT_EQ(Parser.getOffset(), 4u); + EXPECT_TRUE(Parser.done()); + EXPECT_FALSE(Recoverable); + + checkError("parsing line table prologue at offset 0x00000000 unsupported " + "reserved unit length found of value 0xfffffff0", + std::move(Unrecoverable)); +} + +TEST_F(DebugLineBasicFixture, ParserReportsFirstErrorInEachTableWhenParsing) { + if (!setupGenerator()) + return; + + LineTable < = Gen->addLineTable(DWARF32); + LT.setCustomPrologue({{2, LineTable::Long}, {0, LineTable::Half}}); + LineTable <2 = Gen->addLineTable(DWARF32); + LT2.setCustomPrologue({{2, LineTable::Long}, {1, LineTable::Half}}); + generate(); + + DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); + Parser.parseNext(RecordRecoverable, RecordUnrecoverable); + ASSERT_FALSE(Parser.done()); + Parser.parseNext(RecordRecoverable, RecordUnrecoverable); + + EXPECT_TRUE(Parser.done()); + EXPECT_FALSE(Recoverable); + + checkError({"parsing line table prologue at offset 0x00000000 found " + "unsupported version 0x00", + "parsing line table prologue at offset 0x00000006 found " + "unsupported version 0x01"}, + std::move(Unrecoverable)); +} + +TEST_F(DebugLineBasicFixture, ParserReportsNonPrologueProblemsWhenParsing) { + if (!setupGenerator()) + return; + + LineTable < = Gen->addLineTable(DWARF32); + LT.addExtendedOpcode(0x42, DW_LNE_end_sequence, {}); + LineTable <2 = Gen->addLineTable(DWARF32); + LT2.addExtendedOpcode(9, DW_LNE_set_address, + {{0x1234567890abcdef, LineTable::Quad}}); + LT2.addStandardOpcode(DW_LNS_copy, {}); + LT2.addByte(0xbb); + generate(); + + DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); + Parser.parseNext(RecordRecoverable, RecordUnrecoverable); + EXPECT_FALSE(Unrecoverable); + ASSERT_FALSE(Parser.done()); + checkError( + "unexpected line op length at offset 0x00000030 expected 0x42 found 0x01", + std::move(Recoverable)); + + // Reset the error state so that it does not confuse the next set of checks. + Unrecoverable = Error::success(); + Parser.parseNext(RecordRecoverable, RecordUnrecoverable); + + EXPECT_TRUE(Parser.done()); + checkError("last sequence in debug line table at offset 0x00000031 is not " + "terminated", + std::move(Recoverable)); + EXPECT_FALSE(Unrecoverable); +} + +TEST_F(DebugLineBasicFixture, + ParserReportsPrologueErrorsInEachTableWhenSkipping) { + if (!setupGenerator()) + return; + + LineTable < = Gen->addLineTable(DWARF32); + LT.setCustomPrologue({{2, LineTable::Long}, {0, LineTable::Half}}); + LineTable <2 = Gen->addLineTable(DWARF32); + LT2.setCustomPrologue({{2, LineTable::Long}, {1, LineTable::Half}}); + generate(); + + DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); + Parser.skip(RecordRecoverable, RecordUnrecoverable); + ASSERT_FALSE(Parser.done()); + Parser.skip(RecordRecoverable, RecordUnrecoverable); + + EXPECT_TRUE(Parser.done()); + EXPECT_FALSE(Recoverable); + + checkError({"parsing line table prologue at offset 0x00000000 found " + "unsupported version 0x00", + "parsing line table prologue at offset 0x00000006 found " + "unsupported version 0x01"}, + std::move(Unrecoverable)); +} + +TEST_F(DebugLineBasicFixture, ParserIgnoresNonPrologueErrorsWhenSkipping) { + if (!setupGenerator()) + return; + + LineTable < = Gen->addLineTable(DWARF32); + LT.addExtendedOpcode(42, DW_LNE_end_sequence, {}); + generate(); + + DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); + Parser.skip(RecordRecoverable, RecordUnrecoverable); + + EXPECT_TRUE(Parser.done()); + EXPECT_FALSE(Recoverable); + EXPECT_FALSE(Unrecoverable); +} + +TEST_F(DebugLineBasicFixture, ParserPrintsStandardOpcodesWhenRequested) { + if (!setupGenerator()) + return; + + using ValLen = dwarfgen::LineTable::ValueAndLength; + LineTable < = Gen->addLineTable(DWARF32); + LT.addStandardOpcode(DW_LNS_copy, {}); + LT.addStandardOpcode(DW_LNS_advance_pc, {ValLen{11, LineTable::ULEB}}); + LT.addStandardOpcode(DW_LNS_advance_line, {ValLen{22, LineTable::SLEB}}); + LT.addStandardOpcode(DW_LNS_set_file, {ValLen{33, LineTable::ULEB}}); + LT.addStandardOpcode(DW_LNS_set_column, {ValLen{44, LineTable::ULEB}}); + LT.addStandardOpcode(DW_LNS_negate_stmt, {}); + LT.addStandardOpcode(DW_LNS_set_basic_block, {}); + LT.addStandardOpcode(DW_LNS_const_add_pc, {}); + LT.addStandardOpcode(DW_LNS_fixed_advance_pc, {ValLen{55, LineTable::Half}}); + LT.addStandardOpcode(DW_LNS_set_prologue_end, {}); + LT.addStandardOpcode(DW_LNS_set_epilogue_begin, {}); + LT.addStandardOpcode(DW_LNS_set_isa, {ValLen{66, LineTable::ULEB}}); + LT.addExtendedOpcode(1, DW_LNE_end_sequence, {}); + generate(); + + DWARFDebugLine::SectionParser Parser(LineData, *Context, CUs, TUs); + std::string Output; + raw_string_ostream OS(Output); + Parser.parseNext(RecordRecoverable, RecordUnrecoverable, &OS); + OS.flush(); + + EXPECT_FALSE(Recoverable); + EXPECT_FALSE(Unrecoverable); + auto InOutput = [&Output](char const *Str) { + return Output.find(Str) != std::string::npos; + }; + EXPECT_TRUE(InOutput("0x0000002e: 01 DW_LNS_copy\n")) << Output; + EXPECT_TRUE(InOutput("0x0000002f: 02 DW_LNS_advance_pc (11)\n")) << Output; + // FIXME: The value printed after DW_LNS_advance_line is currently the result + // of the advance, but it should be the value being advanced by. See + // https://bugs.llvm.org/show_bug.cgi?id=44261 for details. + EXPECT_TRUE(InOutput("0x00000031: 03 DW_LNS_advance_line (23)\n")) << Output; + EXPECT_TRUE(InOutput("0x00000033: 04 DW_LNS_set_file (33)\n")) << Output; + EXPECT_TRUE(InOutput("0x00000035: 05 DW_LNS_set_column (44)\n")) << Output; + EXPECT_TRUE(InOutput("0x00000037: 06 DW_LNS_negate_stmt\n")) << Output; + EXPECT_TRUE(InOutput("0x00000038: 07 DW_LNS_set_basic_block\n")) << Output; + EXPECT_TRUE( + InOutput("0x00000039: 08 DW_LNS_const_add_pc (0x0000000000000011)\n")) + << Output; + EXPECT_TRUE(InOutput("0x0000003a: 09 DW_LNS_fixed_advance_pc (0x0037)\n")) + << Output; + EXPECT_TRUE(InOutput("0x0000003d: 0a DW_LNS_set_prologue_end\n")) << Output; + EXPECT_TRUE(InOutput("0x0000003e: 0b DW_LNS_set_epilogue_begin\n")) << Output; + EXPECT_TRUE(InOutput("0x0000003f: 0c DW_LNS_set_isa (66)\n")) << Output; +} + +} // end anonymous namespace