| //===- llvm/unittest/DebugInfo/DWARFFormValueTest.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 "llvm/DebugInfo/DWARF/DWARFFormValue.h" |
| #include "llvm/ADT/ArrayRef.h" |
| #include "llvm/ADT/SmallString.h" |
| #include "llvm/BinaryFormat/Dwarf.h" |
| #include "llvm/Support/FormatVariadic.h" |
| #include "llvm/Support/Host.h" |
| #include "llvm/Support/LEB128.h" |
| #include "gtest/gtest.h" |
| #include <climits> |
| using namespace llvm; |
| using namespace dwarf; |
| |
| namespace { |
| |
| bool isFormClass(dwarf::Form Form, DWARFFormValue::FormClass FC) { |
| return DWARFFormValue(Form).isFormClass(FC); |
| } |
| |
| TEST(DWARFFormValue, FormClass) { |
| EXPECT_TRUE(isFormClass(DW_FORM_addr, DWARFFormValue::FC_Address)); |
| EXPECT_FALSE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_Address)); |
| EXPECT_TRUE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_Constant)); |
| EXPECT_TRUE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_SectionOffset)); |
| EXPECT_TRUE( |
| isFormClass(DW_FORM_sec_offset, DWARFFormValue::FC_SectionOffset)); |
| EXPECT_TRUE(isFormClass(DW_FORM_GNU_str_index, DWARFFormValue::FC_String)); |
| EXPECT_TRUE(isFormClass(DW_FORM_GNU_addr_index, DWARFFormValue::FC_Address)); |
| EXPECT_FALSE(isFormClass(DW_FORM_ref_addr, DWARFFormValue::FC_Address)); |
| EXPECT_TRUE(isFormClass(DW_FORM_ref_addr, DWARFFormValue::FC_Reference)); |
| EXPECT_TRUE(isFormClass(DW_FORM_ref_sig8, DWARFFormValue::FC_Reference)); |
| } |
| |
| template<typename RawTypeT> |
| DWARFFormValue createDataXFormValue(dwarf::Form Form, RawTypeT Value) { |
| char Raw[sizeof(RawTypeT)]; |
| memcpy(Raw, &Value, sizeof(RawTypeT)); |
| uint64_t Offset = 0; |
| DWARFFormValue Result(Form); |
| DWARFDataExtractor Data(StringRef(Raw, sizeof(RawTypeT)), |
| sys::IsLittleEndianHost, sizeof(void *)); |
| Result.extractValue(Data, &Offset, {0, 0, dwarf::DwarfFormat::DWARF32}); |
| return Result; |
| } |
| |
| DWARFFormValue createULEBFormValue(uint64_t Value) { |
| SmallString<10> RawData; |
| raw_svector_ostream OS(RawData); |
| encodeULEB128(Value, OS); |
| uint64_t Offset = 0; |
| DWARFFormValue Result(DW_FORM_udata); |
| DWARFDataExtractor Data(OS.str(), sys::IsLittleEndianHost, sizeof(void *)); |
| Result.extractValue(Data, &Offset, {0, 0, dwarf::DwarfFormat::DWARF32}); |
| return Result; |
| } |
| |
| DWARFFormValue createSLEBFormValue(int64_t Value) { |
| SmallString<10> RawData; |
| raw_svector_ostream OS(RawData); |
| encodeSLEB128(Value, OS); |
| uint64_t Offset = 0; |
| DWARFFormValue Result(DW_FORM_sdata); |
| DWARFDataExtractor Data(OS.str(), sys::IsLittleEndianHost, sizeof(void *)); |
| Result.extractValue(Data, &Offset, {0, 0, dwarf::DwarfFormat::DWARF32}); |
| return Result; |
| } |
| |
| TEST(DWARFFormValue, SignedConstantForms) { |
| // Check that we correctly sign extend fixed size forms. |
| auto Sign1 = createDataXFormValue<uint8_t>(DW_FORM_data1, -123); |
| auto Sign2 = createDataXFormValue<uint16_t>(DW_FORM_data2, -12345); |
| auto Sign4 = createDataXFormValue<uint32_t>(DW_FORM_data4, -123456789); |
| auto Sign8 = createDataXFormValue<uint64_t>(DW_FORM_data8, -1); |
| EXPECT_EQ(Sign1.getAsSignedConstant().getValue(), -123); |
| EXPECT_EQ(Sign2.getAsSignedConstant().getValue(), -12345); |
| EXPECT_EQ(Sign4.getAsSignedConstant().getValue(), -123456789); |
| EXPECT_EQ(Sign8.getAsSignedConstant().getValue(), -1); |
| |
| // Check that we can handle big positive values, but that we return |
| // an error just over the limit. |
| auto UMax = createULEBFormValue(LLONG_MAX); |
| auto TooBig = createULEBFormValue(uint64_t(LLONG_MAX) + 1); |
| EXPECT_EQ(UMax.getAsSignedConstant().getValue(), LLONG_MAX); |
| EXPECT_EQ(TooBig.getAsSignedConstant().hasValue(), false); |
| |
| // Sanity check some other forms. |
| auto Data1 = createDataXFormValue<uint8_t>(DW_FORM_data1, 120); |
| auto Data2 = createDataXFormValue<uint16_t>(DW_FORM_data2, 32000); |
| auto Data4 = createDataXFormValue<uint32_t>(DW_FORM_data4, 2000000000); |
| auto Data8 = createDataXFormValue<uint64_t>(DW_FORM_data8, 0x1234567812345678LL); |
| auto LEBMin = createSLEBFormValue(LLONG_MIN); |
| auto LEBMax = createSLEBFormValue(LLONG_MAX); |
| auto LEB1 = createSLEBFormValue(-42); |
| auto LEB2 = createSLEBFormValue(42); |
| EXPECT_EQ(Data1.getAsSignedConstant().getValue(), 120); |
| EXPECT_EQ(Data2.getAsSignedConstant().getValue(), 32000); |
| EXPECT_EQ(Data4.getAsSignedConstant().getValue(), 2000000000); |
| EXPECT_EQ(Data8.getAsSignedConstant().getValue(), 0x1234567812345678LL); |
| EXPECT_EQ(LEBMin.getAsSignedConstant().getValue(), LLONG_MIN); |
| EXPECT_EQ(LEBMax.getAsSignedConstant().getValue(), LLONG_MAX); |
| EXPECT_EQ(LEB1.getAsSignedConstant().getValue(), -42); |
| EXPECT_EQ(LEB2.getAsSignedConstant().getValue(), 42); |
| |
| // Data16 is a little tricky. |
| char Cksum[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; |
| DWARFFormValue Data16(DW_FORM_data16); |
| DWARFDataExtractor DE16(StringRef(Cksum, 16), sys::IsLittleEndianHost, |
| sizeof(void *)); |
| uint64_t Offset = 0; |
| Data16.extractValue(DE16, &Offset, {0, 0, dwarf::DwarfFormat::DWARF32}); |
| SmallString<32> Str; |
| raw_svector_ostream Res(Str); |
| Data16.dump(Res, DIDumpOptions()); |
| EXPECT_EQ(memcmp(Str.data(), "000102030405060708090a0b0c0d0e0f", 32), 0); |
| } |
| |
| using ParamType = std::tuple<Form, uint16_t, uint8_t, DwarfFormat, |
| ArrayRef<uint8_t>, uint64_t, bool>; |
| |
| struct FormSkipValueFixtureBase : public testing::TestWithParam<ParamType> { |
| void SetUp() override { |
| std::tie(Fm, Version, AddrSize, Dwarf, InitialData, ExpectedSkipped, |
| ExpectedResult) = GetParam(); |
| } |
| |
| void doSkipValueTest() { |
| SCOPED_TRACE("Inputs: Form = " + std::to_string(Fm) + |
| ", Version = " + std::to_string(Version) + |
| ", AddrSize = " + std::to_string(uint32_t(AddrSize)) + |
| ", DwarfFormat = " + std::to_string(Dwarf)); |
| std::vector<uint8_t> Buf(InitialData.data(), |
| InitialData.data() + InitialData.size()); |
| // The data extractor only adjusts the offset to the end of the buffer when |
| // attempting to read past the end, so the buffer must be bigger than the |
| // expected amount to be skipped to identify cases where more data than |
| // expected is skipped. |
| Buf.resize(ExpectedSkipped + 1); |
| DWARFDataExtractor Data(Buf, sys::IsLittleEndianHost, AddrSize); |
| uint64_t Offset = 0; |
| EXPECT_EQ(DWARFFormValue::skipValue(Fm, Data, &Offset, |
| {Version, AddrSize, Dwarf}), |
| ExpectedResult); |
| EXPECT_EQ(Offset, ExpectedSkipped); |
| } |
| |
| Form Fm; |
| uint16_t Version; |
| uint8_t AddrSize; |
| DwarfFormat Dwarf; |
| ArrayRef<uint8_t> InitialData; |
| uint64_t ExpectedSkipped; |
| bool ExpectedResult; |
| }; |
| |
| template <typename T> static ArrayRef<uint8_t> toBytes(const T &Input) { |
| return ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(&Input), |
| sizeof(Input)); |
| } |
| |
| const uint8_t LEBData[] = {0x80, 0x1}; |
| ArrayRef<uint8_t> SampleLEB(LEBData, sizeof(LEBData)); |
| const uint8_t SampleLength8 = 0x80; |
| const uint16_t SampleLength16 = 0x80; |
| const uint32_t SampleLength = 0x80; |
| ArrayRef<uint8_t> SampleU8 = toBytes(SampleLength8); |
| ArrayRef<uint8_t> SampleU16 = toBytes(SampleLength16); |
| ArrayRef<uint8_t> SampleU32 = toBytes(SampleLength); |
| const uint8_t StringData[] = "abcdef"; |
| ArrayRef<uint8_t> SampleString(StringData, sizeof(StringData)); |
| const uint8_t IndirectData8[] = {DW_FORM_data8}; |
| const uint8_t IndirectData16[] = {DW_FORM_data16}; |
| const uint8_t IndirectAddr[] = {DW_FORM_addr}; |
| const uint8_t IndirectIndirectData1[] = {DW_FORM_indirect, DW_FORM_data1}; |
| const uint8_t IndirectIndirectEnd[] = {DW_FORM_indirect}; |
| |
| // Gtest's paramterised tests only allow a maximum of 50 cases, so split the |
| // test into multiple identical parts to share the cases. |
| struct FormSkipValueFixture1 : FormSkipValueFixtureBase {}; |
| struct FormSkipValueFixture2 : FormSkipValueFixtureBase {}; |
| TEST_P(FormSkipValueFixture1, skipValuePart1) { doSkipValueTest(); } |
| TEST_P(FormSkipValueFixture2, skipValuePart2) { doSkipValueTest(); } |
| |
| INSTANTIATE_TEST_CASE_P( |
| SkipValueTestParams1, FormSkipValueFixture1, |
| testing::Values( |
| // Form, Version, AddrSize, DwarfFormat, InitialData, ExpectedSize, |
| // ExpectedResult. |
| ParamType(DW_FORM_exprloc, 0, 0, DWARF32, SampleLEB, |
| SampleLength + SampleLEB.size(), true), |
| ParamType(DW_FORM_block, 0, 0, DWARF32, SampleLEB, |
| SampleLength + SampleLEB.size(), true), |
| ParamType(DW_FORM_block1, 0, 0, DWARF32, SampleU8, SampleLength8 + 1, |
| true), |
| ParamType(DW_FORM_block2, 0, 0, DWARF32, SampleU16, SampleLength16 + 2, |
| true), |
| ParamType(DW_FORM_block4, 0, 0, DWARF32, SampleU32, SampleLength + 4, |
| true), |
| ParamType(DW_FORM_string, 0, 0, DWARF32, SampleString, |
| SampleString.size(), true), |
| ParamType(DW_FORM_addr, 0, 42, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_addr, 4, 0, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_addr, 4, 42, DWARF32, SampleU32, 42, true), |
| ParamType(DW_FORM_ref_addr, 0, 1, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_ref_addr, 1, 0, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_ref_addr, 1, 1, DWARF32, SampleU32, 4, true), |
| ParamType(DW_FORM_ref_addr, 1, 1, DWARF64, SampleU32, 8, true), |
| ParamType(DW_FORM_ref_addr, 2, 42, DWARF32, SampleU32, 42, true), |
| ParamType(DW_FORM_ref_addr, 2, 42, DWARF64, SampleU32, 42, true), |
| ParamType(DW_FORM_ref_addr, 3, 3, DWARF32, SampleU32, 4, true), |
| ParamType(DW_FORM_ref_addr, 3, 3, DWARF64, SampleU32, 8, true), |
| ParamType(DW_FORM_flag_present, 4, 4, DWARF32, SampleU32, 0, true), |
| ParamType(DW_FORM_data1, 0, 0, DWARF32, SampleU32, 1, true), |
| ParamType(DW_FORM_data2, 0, 0, DWARF32, SampleU32, 2, true), |
| ParamType(DW_FORM_data4, 0, 0, DWARF32, SampleU32, 4, true), |
| ParamType(DW_FORM_data8, 0, 0, DWARF32, SampleU32, 8, true), |
| ParamType(DW_FORM_data16, 0, 0, DWARF32, SampleU32, 16, true), |
| ParamType(DW_FORM_flag, 0, 0, DWARF32, SampleU32, 1, true), |
| ParamType(DW_FORM_ref1, 0, 0, DWARF32, SampleU32, 1, true), |
| ParamType(DW_FORM_ref2, 0, 0, DWARF32, SampleU32, 2, true), |
| ParamType(DW_FORM_ref4, 0, 0, DWARF32, SampleU32, 4, true), |
| ParamType(DW_FORM_ref8, 0, 0, DWARF32, SampleU32, 8, true), |
| ParamType(DW_FORM_ref_sig8, 0, 0, DWARF32, SampleU32, 8, true), |
| ParamType(DW_FORM_ref_sup4, 0, 0, DWARF32, SampleU32, 4, true), |
| ParamType(DW_FORM_ref_sup8, 0, 0, DWARF32, SampleU32, 8, true), |
| ParamType(DW_FORM_strx1, 0, 0, DWARF32, SampleU32, 1, true), |
| ParamType(DW_FORM_strx2, 0, 0, DWARF32, SampleU32, 2, true), |
| ParamType(DW_FORM_strx4, 0, 0, DWARF32, SampleU32, 4, true), |
| ParamType(DW_FORM_addrx1, 0, 0, DWARF32, SampleU32, 1, true), |
| ParamType(DW_FORM_addrx2, 0, 0, DWARF32, SampleU32, 2, true), |
| ParamType(DW_FORM_addrx4, 0, 0, DWARF32, SampleU32, 4, true), |
| ParamType(DW_FORM_sec_offset, 0, 1, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_sec_offset, 1, 0, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_sec_offset, 1, 1, DWARF32, SampleU32, 4, true), |
| ParamType(DW_FORM_sec_offset, 1, 1, DWARF64, SampleU32, 8, true), |
| ParamType(DW_FORM_strp, 0, 1, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_strp, 1, 0, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_strp, 1, 1, DWARF32, SampleU32, 4, true), |
| ParamType(DW_FORM_strp, 1, 1, DWARF64, SampleU32, 8, true), |
| ParamType(DW_FORM_strp_sup, 0, 1, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_strp_sup, 1, 0, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_strp_sup, 1, 1, DWARF32, SampleU32, 4, true), |
| ParamType(DW_FORM_strp_sup, 1, 1, DWARF64, SampleU32, 8, true)), ); |
| |
| INSTANTIATE_TEST_CASE_P( |
| SkipValueTestParams2, FormSkipValueFixture2, |
| testing::Values( |
| ParamType(DW_FORM_line_strp, 0, 1, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_line_strp, 1, 0, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_line_strp, 1, 1, DWARF32, SampleU32, 4, true), |
| ParamType(DW_FORM_line_strp, 1, 1, DWARF64, SampleU32, 8, true), |
| ParamType(DW_FORM_GNU_ref_alt, 0, 1, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_GNU_ref_alt, 1, 0, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_GNU_ref_alt, 1, 1, DWARF32, SampleU32, 4, true), |
| ParamType(DW_FORM_GNU_ref_alt, 1, 1, DWARF64, SampleU32, 8, true), |
| ParamType(DW_FORM_GNU_strp_alt, 0, 1, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_GNU_strp_alt, 1, 0, DWARF32, SampleU32, 0, false), |
| ParamType(DW_FORM_GNU_strp_alt, 1, 1, DWARF32, SampleU32, 4, true), |
| ParamType(DW_FORM_GNU_strp_alt, 1, 1, DWARF64, SampleU32, 8, true), |
| ParamType(DW_FORM_sdata, 0, 0, DWARF32, SampleLEB, SampleLEB.size(), |
| true), |
| ParamType(DW_FORM_udata, 0, 0, DWARF32, SampleLEB, SampleLEB.size(), |
| true), |
| ParamType(DW_FORM_ref_udata, 0, 0, DWARF32, SampleLEB, SampleLEB.size(), |
| true), |
| ParamType(DW_FORM_strx, 0, 0, DWARF32, SampleLEB, SampleLEB.size(), |
| true), |
| ParamType(DW_FORM_addrx, 0, 0, DWARF32, SampleLEB, SampleLEB.size(), |
| true), |
| ParamType(DW_FORM_loclistx, 0, 0, DWARF32, SampleLEB, SampleLEB.size(), |
| true), |
| ParamType(DW_FORM_rnglistx, 0, 0, DWARF32, SampleLEB, SampleLEB.size(), |
| true), |
| ParamType(DW_FORM_GNU_addr_index, 0, 0, DWARF32, SampleLEB, |
| SampleLEB.size(), true), |
| ParamType(DW_FORM_GNU_str_index, 0, 0, DWARF32, SampleLEB, |
| SampleLEB.size(), true), |
| ParamType(DW_FORM_indirect, 0, 0, DWARF32, |
| ArrayRef<uint8_t>(IndirectData8, sizeof(IndirectData8)), 9, |
| true), |
| ParamType(DW_FORM_indirect, 0, 0, DWARF32, |
| ArrayRef<uint8_t>(IndirectData16, sizeof(IndirectData16)), 17, |
| true), |
| ParamType(DW_FORM_indirect, 4, 0, DWARF32, |
| ArrayRef<uint8_t>(IndirectAddr, sizeof(IndirectAddr)), 1, |
| false), |
| ParamType(DW_FORM_indirect, 4, 4, DWARF32, |
| ArrayRef<uint8_t>(IndirectAddr, sizeof(IndirectAddr)), 5, |
| true), |
| ParamType(DW_FORM_indirect, 4, 4, DWARF32, |
| ArrayRef<uint8_t>(IndirectIndirectData1, |
| sizeof(IndirectIndirectData1)), |
| 3, true), |
| ParamType(DW_FORM_indirect, 4, 4, DWARF32, |
| ArrayRef<uint8_t>(IndirectIndirectEnd, |
| sizeof(IndirectIndirectEnd)), |
| 2, false), |
| ParamType(/*Unknown=*/Form(0xff), 4, 4, DWARF32, SampleU32, 0, |
| false)), ); |
| |
| using ErrorParams = std::tuple<Form, std::vector<uint8_t>>; |
| struct ExtractValueErrorFixture : public testing::TestWithParam<ErrorParams> { |
| void SetUp() override { std::tie(Fm, InitialData) = GetParam(); } |
| |
| Form Fm; |
| ArrayRef<uint8_t> InitialData; |
| }; |
| |
| TEST_P(ExtractValueErrorFixture, Test) { |
| SCOPED_TRACE(formatv("Fm = {0}, InitialData = {1}", Fm, |
| make_range(InitialData.begin(), InitialData.end())) |
| .str()); |
| |
| DWARFDataExtractor Data(InitialData, sys::IsLittleEndianHost, 4); |
| DWARFFormValue Form(Fm); |
| uint64_t Offset = 0; |
| EXPECT_FALSE(Form.extractValue(Data, &Offset, {0, 0, DWARF32})); |
| } |
| |
| INSTANTIATE_TEST_CASE_P( |
| ExtractValueErrorParams, ExtractValueErrorFixture, |
| testing::Values( |
| ErrorParams{DW_FORM_ref_addr, {}}, ErrorParams{DW_FORM_block, {}}, |
| ErrorParams{DW_FORM_block, {1}}, ErrorParams{DW_FORM_block, {2, 0}}, |
| ErrorParams{DW_FORM_block1, {}}, ErrorParams{DW_FORM_block2, {}}, |
| ErrorParams{DW_FORM_block4, {}}, ErrorParams{DW_FORM_data1, {}}, |
| ErrorParams{DW_FORM_data2, {}}, ErrorParams{DW_FORM_strx3, {}}, |
| ErrorParams{DW_FORM_data4, {}}, ErrorParams{DW_FORM_data8, {}}, |
| ErrorParams{DW_FORM_data16, {}}, ErrorParams{DW_FORM_sdata, {}}, |
| ErrorParams{DW_FORM_udata, {}}, ErrorParams{DW_FORM_string, {}}, |
| ErrorParams{DW_FORM_indirect, {}}, |
| ErrorParams{DW_FORM_indirect, {DW_FORM_data1}}, |
| ErrorParams{DW_FORM_strp_sup, {}}, |
| ErrorParams{DW_FORM_ref_sig8, {}}), ); |
| |
| using DumpValueParams = |
| std::tuple<Form, ArrayRef<uint8_t>, DwarfFormat, StringRef>; |
| struct DumpValueFixture : public testing::TestWithParam<DumpValueParams> { |
| void SetUp() override { |
| std::tie(Fm, InitialData, Format, ExpectedResult) = GetParam(); |
| } |
| |
| Form Fm; |
| ArrayRef<uint8_t> InitialData; |
| DwarfFormat Format; |
| StringRef ExpectedResult; |
| }; |
| |
| TEST_P(DumpValueFixture, Test) { |
| SCOPED_TRACE(formatv("Fm = {0}, InitialData = [{1}], Format = {2}", Fm, |
| toHex(InitialData), |
| Format == DWARF64 ? "DWARF64" : "DWARF32")); |
| DWARFDataExtractor Data(InitialData, sys::IsLittleEndianHost, 8); |
| DWARFFormValue Form(Fm); |
| uint64_t Offset = 0; |
| Form.extractValue(Data, &Offset, {0, 0, Format}); |
| |
| std::string Output; |
| raw_string_ostream OS(Output); |
| |
| DIDumpOptions Opts; |
| Opts.Verbose = true; |
| Opts.ShowAddresses = true; |
| |
| Form.dump(OS, Opts); |
| OS.flush(); |
| |
| EXPECT_EQ(Output, ExpectedResult); |
| } |
| |
| const uint32_t DumpTestSample32Val = 0x112233; |
| ArrayRef<uint8_t> DumpTestSample32 = toBytes(DumpTestSample32Val); |
| const uint64_t DumpTestSample64Val = 0x11223344556677; |
| ArrayRef<uint8_t> DumpTestSample64 = toBytes(DumpTestSample64Val); |
| |
| INSTANTIATE_TEST_CASE_P( |
| DumpValueParams, DumpValueFixture, |
| testing::Values(DumpValueParams{DW_FORM_strp, DumpTestSample32, DWARF32, |
| " .debug_str[0x00112233] = "}, |
| DumpValueParams{DW_FORM_strp, DumpTestSample64, DWARF64, |
| " .debug_str[0x0011223344556677] = "}, |
| DumpValueParams{DW_FORM_line_strp, DumpTestSample32, |
| DWARF32, " .debug_line_str[0x00112233] = "}, |
| DumpValueParams{DW_FORM_line_strp, DumpTestSample64, |
| DWARF64, |
| " .debug_line_str[0x0011223344556677] = "}, |
| DumpValueParams{DW_FORM_sec_offset, DumpTestSample32, |
| DWARF32, "0x00112233"}, |
| DumpValueParams{DW_FORM_sec_offset, DumpTestSample64, |
| DWARF64, "0x0011223344556677"}), ); |
| |
| } // end anonymous namespace |
