This is an archive of the discontinued LLVM Phabricator instance.

Differential D72443

[DebugInfo] Improve error message text
ClosedPublic

Authored by jhenderson on Jan 9 2020, 4:23 AM.

Details

Reviewers
dblaikie
JDevlieghere
ikudrin
MaskRay
probinson
• espindola
Commits
rG6e3ca962fafb: [DebugInfo] Improve error message text
Summary

Unlike most of our errors in the debug line parser, the "no end of sequence" message was missing any reference to which line table it refererred to. This change adds the offset to this message.

Diff Detail

Event Timeline

jhenderson created this revision.Jan 9 2020, 4:23 AM
Herald added a project: Restricted Project. · View Herald TranscriptJan 9 2020, 4:23 AM
Herald added a subscriber: hiraditya. · View Herald Transcript
jhenderson updated this revision to Diff 237045.Jan 9 2020, 5:59 AM

Update missed test.

dblaikie accepted this revision.Jan 9 2020, 4:55 PM

Seems good

This revision is now accepted and ready to land.Jan 9 2020, 4:55 PM
jhenderson updated this revision to Diff 237310.Jan 10 2020, 6:58 AM

Rebase on master and add missed lld test.

Herald added a reviewer: • espindola. · View Herald TranscriptJan 10 2020, 6:58 AM
Herald added a subscriber: emaste. · View Herald Transcript
Closed by commit rG6e3ca962fafb: [DebugInfo] Improve error message text (authored by jhenderson). · Explain WhyJan 10 2020, 7:05 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
lld/
test/
ELF/
2 lines
llvm/
lib/
DebugInfo/
DWARF/
8 lines
test/
tools/
llvm-dwarfdump/
X86/
2 lines
unittests/
DebugInfo/
DWARF/
1524 lines

Diff 237313

lld/test/ELF/undef.s

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
# CHECK: error: undefined symbol: zed5 # CHECK: error: undefined symbol: zed5
# CHECK-NEXT: >>> referenced by undef-debug.s:11 (dir{{/|\\}}undef-debug.s:11) # CHECK-NEXT: >>> referenced by undef-debug.s:11 (dir{{/|\\}}undef-debug.s:11)
# CHECK-NEXT: >>> {{.*}}.o:(.text.2+0x0) # CHECK-NEXT: >>> {{.*}}.o:(.text.2+0x0)
# Show that all line table problems are mentioned as soon as the object's line information # Show that all line table problems are mentioned as soon as the object's line information
# is requested, even if that particular part of the line information is not currently required. # is requested, even if that particular part of the line information is not currently required.
# Also show that the warnings are only printed once. # Also show that the warnings are only printed once.
# CHECK: warning: parsing line table prologue at 0x00000000 should have ended at 0x00000038 but it ended at 0x00000037 # CHECK: warning: parsing line table prologue at 0x00000000 should have ended at 0x00000038 but it ended at 0x00000037
# CHECK-NEXT: warning: last sequence in debug line table is not terminated! # CHECK-NEXT: warning: last sequence in debug line table at offset 0x0000005b is not terminated
# CHECK: error: undefined symbol: zed6a # CHECK: error: undefined symbol: zed6a
# CHECK-NEXT: >>> referenced by {{.*}}tmp4.o:(.text+0x0) # CHECK-NEXT: >>> referenced by {{.*}}tmp4.o:(.text+0x0)
# CHECK: error: undefined symbol: zed6b # CHECK: error: undefined symbol: zed6b
# CHECK-NEXT: >>> referenced by {{.*}}tmp4.o:(.text+0x8) # CHECK-NEXT: >>> referenced by {{.*}}tmp4.o:(.text+0x8)
# Show that a problem with one line table's information doesn't affect getting information from # Show that a problem with one line table's information doesn't affect getting information from
# a different one in the same object. # a different one in the same object.
# CHECK: error: undefined symbol: zed7 # CHECK: error: undefined symbol: zed7
Show All 17 Lines

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

Show First 20 Lines • Show All 877 Lines • ▼ Show 20 Lines if (Opcode == 0) {
State.appendRowToMatrix(); State.appendRowToMatrix();
} }
if(OS) if(OS)
*OS << "\n"; *OS << "\n";
} }
if (!State.Sequence.Empty) if (!State.Sequence.Empty)
RecoverableErrorCallback( RecoverableErrorCallback(createStringError(
createStringError(errc::illegal_byte_sequence, errc::illegal_byte_sequence,
"last sequence in debug line table is not terminated!")); "last sequence in debug line table at offset 0x%8.8" PRIx64
" is not terminated",
DebugLineOffset));
// Sort all sequences so that address lookup will work faster. // Sort all sequences so that address lookup will work faster.
if (!Sequences.empty()) { if (!Sequences.empty()) {
llvm::sort(Sequences, Sequence::orderByHighPC); llvm::sort(Sequences, Sequence::orderByHighPC);
// Note: actually, instruction address ranges of sequences should not // Note: actually, instruction address ranges of sequences should not
// overlap (in shared objects and executables). If they do, the address // overlap (in shared objects and executables). If they do, the address
// lookup would still work, though, but result would be ambiguous. // lookup would still work, though, but result would be ambiguous.
// We don't report warning in this case. For example, // We don't report warning in this case. For example,
▲ Show 20 Lines • Show All 283 Lines • Show Last 20 Lines

llvm/test/tools/llvm-dwarfdump/X86/debug_line_invalid.test

Show First 20 Lines • Show All 152 Lines • ▼ Show 20 Lines
# ALL: warning: parsing line table prologue at offset 0x00000048 found unsupported version 0x00 # ALL: warning: parsing line table prologue at offset 0x00000048 found unsupported version 0x00
# ALL-NEXT: warning: parsing line table prologue at offset 0x0000004e found unsupported version 0x01 # ALL-NEXT: warning: parsing line table prologue at offset 0x0000004e found unsupported version 0x01
# ALL-NEXT: warning: parsing line table prologue at 0x00000054 found an invalid directory or file table description at 0x00000073 # ALL-NEXT: warning: parsing line table prologue at 0x00000054 found an invalid directory or file table description at 0x00000073
# ALL-NEXT: warning: failed to parse entry content descriptions because no path was found # ALL-NEXT: warning: failed to parse entry content descriptions because no path was found
# FIXME - The latter offset in the next line should be 0xad. The filename parsing code does not notice a missing terminating byte. # FIXME - The latter offset in the next line should be 0xad. The filename parsing code does not notice a missing terminating byte.
# ALL-NEXT: warning: parsing line table prologue at 0x00000081 should have ended at 0x000000b9 but it ended at 0x000000ba # ALL-NEXT: warning: parsing line table prologue at 0x00000081 should have ended at 0x000000b9 but it ended at 0x000000ba
# ALL-NEXT: warning: parsing line table prologue at 0x000000c9 should have ended at 0x00000104 but it ended at 0x00000103 # ALL-NEXT: warning: parsing line table prologue at 0x000000c9 should have ended at 0x00000104 but it ended at 0x00000103
# OTHER-NEXT: warning: unexpected line op length at offset 0x00000158 expected 0x02 found 0x01 # OTHER-NEXT: warning: unexpected line op length at offset 0x00000158 expected 0x02 found 0x01
# OTHER-NEXT: warning: last sequence in debug line table is not terminated! # OTHER-NEXT: warning: last sequence in debug line table at offset 0x00000167 is not terminated
# ALL-NEXT: warning: parsing line table prologue at 0x000001ad should have ended at 0x000001c8 but it ended at 0x000001df # ALL-NEXT: warning: parsing line table prologue at 0x000001ad should have ended at 0x000001c8 but it ended at 0x000001df
# ALL-NEXT: warning: parsing line table prologue at 0x000001ed should have ended at 0x00000218 but it ended at 0x0000021f # ALL-NEXT: warning: parsing line table prologue at 0x000001ed should have ended at 0x00000218 but it ended at 0x0000021f
# ALL-NEXT: warning: parsing line table prologue at 0x0000022d should have ended at 0x0000024f but it ended at 0x0000025f # ALL-NEXT: warning: parsing line table prologue at 0x0000022d should have ended at 0x0000024f but it ended at 0x0000025f
# ALL-NEXT: warning: parsing line table prologue at 0x0000026d found an invalid directory or file table description at 0x000002a2 # ALL-NEXT: warning: parsing line table prologue at 0x0000026d found an invalid directory or file table description at 0x000002a2
# ALL-NEXT: warning: failed to parse file entry because the MD5 hash is invalid # ALL-NEXT: warning: failed to parse file entry because the MD5 hash is invalid
# ALL-NOT: warning: # ALL-NOT: warning:

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

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