| // Copyright 2024 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <lib/elfldltl/dwarf/cfi-entry.h> |
| #include <lib/elfldltl/dwarf/eh-frame-hdr.h> |
| #include <lib/elfldltl/dwarf/encoding.h> |
| #include <lib/elfldltl/dwarf/section-data.h> |
| #include <lib/elfldltl/memory.h> |
| #include <lib/elfldltl/testing/diagnostics.h> |
| #include <lib/elfldltl/testing/typed-test.h> |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| |
| namespace { |
| |
| using ::testing::AllOf; |
| using ::testing::ElementsAre; |
| using ::testing::ElementsAreArray; |
| using ::testing::Eq; |
| using ::testing::Field; |
| using ::testing::FieldsAre; |
| using ::testing::Optional; |
| |
| FORMAT_TYPED_TEST_SUITE(ElfldltlDwarfTests); |
| |
| template <class Elf> |
| struct InitialLength32 { |
| typename Elf::Word length = 0; |
| }; |
| |
| template <class Elf> |
| struct [[gnu::packed]] InitialLength64 { |
| constexpr InitialLength64() = default; |
| |
| constexpr explicit InitialLength64(uint64_t n) : length{n} {} |
| |
| [[gnu::packed]] const uint32_t dwarf64_marker = 0xffffffff; |
| [[gnu::packed]] typename Elf::Xword length = 0; |
| }; |
| |
| template <class Length, typename T> |
| struct [[gnu::packed]] TestData { |
| constexpr TestData() = default; |
| |
| explicit constexpr TestData(const T& data) : contents{data} {} |
| |
| [[gnu::packed]] Length initial_length{sizeof(T)}; |
| [[gnu::packed]] T contents{}; |
| }; |
| |
| template <typename T> |
| constexpr cpp20::span<const std::byte> AsBytes(T& data) { |
| return cpp20::as_bytes(cpp20::span{&data, 1}); |
| } |
| |
| constexpr elfldltl::FileAddress kErrorArg{0x123u}; |
| |
| constexpr cpp20::span<const std::byte> kNoBytes{}; |
| |
| TYPED_TEST(ElfldltlDwarfTests, SectionDataEmpty) { |
| using Elf = typename TestFixture::Elf; |
| |
| elfldltl::dwarf::SectionData section_data; |
| EXPECT_TRUE(section_data.contents().empty()); |
| |
| auto diag = elfldltl::testing::ExpectOkDiagnostics(); |
| |
| { |
| constexpr InitialLength32<Elf> kEmpty; |
| auto read = elfldltl::dwarf::SectionData::Read<Elf>(diag, AsBytes(kEmpty)); |
| ASSERT_TRUE(read); |
| EXPECT_EQ(read->size_bytes(), 4u); |
| EXPECT_EQ(read->contents().size_bytes(), 0u); |
| } |
| |
| { |
| constexpr InitialLength64<Elf> kEmpty; |
| auto read = elfldltl::dwarf::SectionData::Read<Elf>(diag, AsBytes(kEmpty)); |
| ASSERT_TRUE(read); |
| EXPECT_EQ(read->size_bytes(), 12u); |
| EXPECT_EQ(read->contents().size_bytes(), 0u); |
| } |
| } |
| |
| TYPED_TEST(ElfldltlDwarfTests, SectionDataRead) { |
| using Elf = typename TestFixture::Elf; |
| |
| auto diag = elfldltl::testing::ExpectOkDiagnostics(); |
| |
| static constexpr std::byte kOneByte{17}; |
| { |
| constexpr TestData<InitialLength32<Elf>, std::byte> kOneByteData{kOneByte}; |
| auto read = elfldltl::dwarf::SectionData::Read<Elf>(diag, AsBytes(kOneByteData)); |
| ASSERT_TRUE(read); |
| EXPECT_EQ(read->size_bytes(), sizeof(kOneByteData)); |
| EXPECT_EQ(read->format(), elfldltl::dwarf::SectionData::Format::kDwarf32); |
| EXPECT_EQ(read->initial_length_size(), 4u); |
| EXPECT_EQ(read->offset_size(), 4u); |
| EXPECT_EQ(read->contents().size(), 1u); |
| EXPECT_THAT(read->contents(), ElementsAre(kOneByte)); |
| } |
| { |
| constexpr TestData<InitialLength64<Elf>, std::byte> kOneByteData{kOneByte}; |
| auto read = elfldltl::dwarf::SectionData::Read<Elf>(diag, AsBytes(kOneByteData)); |
| ASSERT_TRUE(read); |
| EXPECT_EQ(read->size_bytes(), sizeof(kOneByteData)); |
| EXPECT_EQ(read->format(), elfldltl::dwarf::SectionData::Format::kDwarf64); |
| EXPECT_EQ(read->initial_length_size(), 12u); |
| EXPECT_EQ(read->offset_size(), 8u); |
| EXPECT_EQ(read->contents().size(), 1u); |
| EXPECT_THAT(read->contents(), ElementsAre(kOneByte)); |
| } |
| } |
| |
| TYPED_TEST(ElfldltlDwarfTests, SectionDataConsume) { |
| using Elf = typename TestFixture::Elf; |
| |
| auto diag = elfldltl::testing::ExpectOkDiagnostics(); |
| |
| static constexpr std::byte kOneByte{17}; |
| constexpr struct { |
| TestData<InitialLength32<Elf>, std::byte> data{kOneByte}; |
| std::array<std::byte, 3> rest{std::byte{1}, std::byte{2}, std::byte{3}}; |
| } kData; |
| |
| auto [read, rest] = elfldltl::dwarf::SectionData::Consume<Elf>(diag, AsBytes(kData)); |
| ASSERT_TRUE(read); |
| EXPECT_EQ(read->contents().size(), 1u); |
| EXPECT_THAT(read->contents(), ElementsAre(kOneByte)); |
| EXPECT_THAT(rest, ElementsAreArray(kData.rest)); |
| } |
| |
| TYPED_TEST(ElfldltlDwarfTests, SectionDataReadOffset) { |
| using Elf = typename TestFixture::Elf; |
| |
| auto diag = elfldltl::testing::ExpectOkDiagnostics(); |
| |
| { |
| struct [[gnu::packed]] DataWithOffset { |
| std::byte extra_byte{23}; |
| [[gnu::packed]] typename Elf::Word offset{1234}; |
| }; |
| constexpr TestData<InitialLength32<Elf>, DataWithOffset> kDataWithOffset; |
| auto read = elfldltl::dwarf::SectionData::Read<Elf>(diag, AsBytes(kDataWithOffset)); |
| ASSERT_TRUE(read); |
| EXPECT_EQ(read->contents().size_bytes(), 5u); |
| auto offset = read->template read_offset<Elf>(1); |
| EXPECT_THAT(offset, Optional(Eq(1234u))); |
| } |
| { |
| struct [[gnu::packed]] DataWithOffset { |
| std::byte extra_byte{23}; |
| [[gnu::packed]] typename Elf::Xword offset{1234567890}; |
| }; |
| constexpr TestData<InitialLength64<Elf>, DataWithOffset> kDataWithOffset; |
| auto read = elfldltl::dwarf::SectionData::Read<Elf>(diag, AsBytes(kDataWithOffset)); |
| ASSERT_TRUE(read); |
| EXPECT_EQ(read->contents().size_bytes(), 9u); |
| auto offset = read->template read_offset<Elf>(1); |
| EXPECT_THAT(offset, Optional(Eq(1234567890u))); |
| } |
| } |
| |
| TYPED_TEST(ElfldltlDwarfTests, SectionDataReadFail) { |
| using Elf = typename TestFixture::Elf; |
| |
| // Empty buffer. |
| { |
| elfldltl::testing::ExpectedSingleError expected{ |
| "data size ", |
| 0, |
| " too small for DWARF header", |
| kErrorArg, |
| }; |
| auto read = elfldltl::dwarf::SectionData::Read<Elf>(expected, kNoBytes, kErrorArg); |
| EXPECT_FALSE(read); |
| } |
| |
| // Buffer too short for any initial length. |
| { |
| constexpr std::array<std::byte, 3> kTooShortForHeader = {}; |
| elfldltl::testing::ExpectedSingleError expected{ |
| "data size ", |
| kTooShortForHeader.size(), |
| " too small for DWARF header", |
| kErrorArg, |
| }; |
| auto read = |
| elfldltl::dwarf::SectionData::Read<Elf>(expected, AsBytes(kTooShortForHeader), kErrorArg); |
| EXPECT_FALSE(read); |
| } |
| |
| // Buffer too short for 64-bit initial length. |
| { |
| constexpr std::array<std::byte, 8> kTooShortForHeader64 = { |
| std::byte{0xff}, |
| std::byte{0xff}, |
| std::byte{0xff}, |
| std::byte{0xff}, |
| }; |
| elfldltl::testing::ExpectedSingleError expected{ |
| "data size ", |
| kTooShortForHeader64.size(), |
| " too small for DWARF header", |
| kErrorArg, |
| }; |
| auto read = |
| elfldltl::dwarf::SectionData::Read<Elf>(expected, AsBytes(kTooShortForHeader64), kErrorArg); |
| EXPECT_FALSE(read); |
| } |
| |
| // Reserved initial length values. |
| for (uint32_t value = elfldltl::dwarf::kDwarf32Limit; value < elfldltl::dwarf::kDwarf64Length; |
| ++value) { |
| const InitialLength32<Elf> kReserved{value}; |
| elfldltl::testing::ExpectedSingleError expected{ |
| "Reserved initial-length value ", |
| value, |
| " used in DWARF header", |
| kErrorArg, |
| }; |
| auto read = elfldltl::dwarf::SectionData::Read<Elf>(expected, AsBytes(kReserved), kErrorArg); |
| EXPECT_FALSE(read); |
| } |
| |
| // Truncated contents for 32-bit length. |
| { |
| constexpr InitialLength32<Elf> kTooShortForLength{1}; |
| elfldltl::testing::ExpectedSingleError expected{ |
| "data size ", 4, " < ", 5, " required by DWARF header", kErrorArg, |
| }; |
| auto read = |
| elfldltl::dwarf::SectionData::Read<Elf>(expected, AsBytes(kTooShortForLength), kErrorArg); |
| EXPECT_FALSE(read); |
| } |
| |
| // Truncated contents for 64-bit length. |
| { |
| constexpr InitialLength64<Elf> kTooShortForLength64{1}; |
| elfldltl::testing::ExpectedSingleError expected{ |
| "data size ", 12, " < ", 13, " required by DWARF header", kErrorArg, |
| }; |
| auto read = |
| elfldltl::dwarf::SectionData::Read<Elf>(expected, AsBytes(kTooShortForLength64), kErrorArg); |
| EXPECT_FALSE(read); |
| } |
| } |
| |
| TEST(ElfldltlDwarfTests, Uleb128) { |
| EXPECT_EQ(elfldltl::dwarf::Uleb128::Read(kNoBytes), std::nullopt); |
| |
| constexpr uint8_t kOneByte{17}; |
| EXPECT_THAT(elfldltl::dwarf::Uleb128::Read(AsBytes(kOneByte)), Optional(FieldsAre(17u, 1u))); |
| |
| constexpr uint8_t kTwoByte[] = {0x80 | (0xaau & 0x7f), 0xaau >> 7}; |
| EXPECT_THAT(elfldltl::dwarf::Uleb128::Read(AsBytes(kTwoByte)), Optional(FieldsAre(0xaau, 2u))); |
| |
| constexpr uint8_t kThreeByte[] = { |
| 0x80 | (0xaabbu & 0x7f), |
| 0x80 | ((0xaabbu >> 7) & 0x7f), |
| ((0xaabbu >> 14) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Uleb128::Read(AsBytes(kThreeByte)), |
| Optional(FieldsAre(0xaabbu, 3u))); |
| |
| constexpr uint8_t kFourByte[] = { |
| 0x80 | (0xaabbccu & 0x7f), |
| 0x80 | ((0xaabbccu >> 7) & 0x7f), |
| 0x80 | ((0xaabbccu >> 14) & 0x7f), |
| ((0xaabbccu >> 21) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Uleb128::Read(AsBytes(kFourByte)), |
| Optional(FieldsAre(0xaabbccu, 4u))); |
| |
| constexpr uint8_t kFiveByte[] = { |
| 0x80 | (0xaabbccddu & 0x7f), 0x80 | ((0xaabbccddu >> 7) & 0x7f), |
| 0x80 | ((0xaabbccddu >> 14) & 0x7f), 0x80 | ((0xaabbccddu >> 21) & 0x7f), |
| ((0xaabbccdd >> 28) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Uleb128::Read(AsBytes(kFiveByte)), |
| Optional(FieldsAre(0xaabbccddu, 5u))); |
| |
| constexpr uint8_t kSixByte[] = { |
| 0x80 | (0xaabbccddeeu & 0x7f), 0x80 | ((0xaabbccddeeu >> 7) & 0x7f), |
| 0x80 | ((0xaabbccddeeu >> 14) & 0x7f), 0x80 | ((0xaabbccddeeu >> 21) & 0x7f), |
| 0x80 | ((0xaabbccddeeu >> 28) & 0x7f), ((0xaabbccddeeu >> 35) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Uleb128::Read(AsBytes(kSixByte)), |
| Optional(FieldsAre(0xaabbccddeeu, 6u))); |
| |
| constexpr uint8_t kSevenByte[] = { |
| 0x80 | (0xaabbccddeeffu & 0x7f), 0x80 | ((0xaabbccddeeffu >> 7) & 0x7f), |
| 0x80 | ((0xaabbccddeeffu >> 14) & 0x7f), 0x80 | ((0xaabbccddeeffu >> 21) & 0x7f), |
| 0x80 | ((0xaabbccddeeffu >> 28) & 0x7f), 0x80 | ((0xaabbccddeeffu >> 35) & 0x7f), |
| ((0xaabbccddeeffu >> 42) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Uleb128::Read(AsBytes(kSevenByte)), |
| Optional(FieldsAre(0xaabbccddeeffu, 7u))); |
| |
| constexpr uint8_t kEightByte[] = { |
| 0x80 | (0xaabbccddeeff11u & 0x7f), 0x80 | ((0xaabbccddeeff11u >> 7) & 0x7f), |
| 0x80 | ((0xaabbccddeeff11u >> 14) & 0x7f), 0x80 | ((0xaabbccddeeff11u >> 21) & 0x7f), |
| 0x80 | ((0xaabbccddeeff11u >> 28) & 0x7f), 0x80 | ((0xaabbccddeeff11u >> 35) & 0x7f), |
| 0x80 | ((0xaabbccddeeff11u >> 42) & 0x7f), ((0xaabbccddeeff11u >> 49) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Uleb128::Read(AsBytes(kEightByte)), |
| Optional(FieldsAre(0xaabbccddeeff11u, 8u))); |
| |
| constexpr uint8_t kNineByte[] = { |
| 0x80 | (0x77bbccddeeff1122u & 0x7f), 0x80 | ((0x77bbccddeeff1122u >> 7) & 0x7f), |
| 0x80 | ((0x77bbccddeeff1122u >> 14) & 0x7f), 0x80 | ((0x77bbccddeeff1122u >> 21) & 0x7f), |
| 0x80 | ((0x77bbccddeeff1122u >> 28) & 0x7f), 0x80 | ((0x77bbccddeeff1122u >> 35) & 0x7f), |
| 0x80 | ((0x77bbccddeeff1122u >> 42) & 0x7f), 0x80 | ((0x77bbccddeeff1122u >> 49) & 0x7f), |
| ((0x77bbccddeeff1122u >> 56) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Uleb128::Read(AsBytes(kNineByte)), |
| Optional(FieldsAre(0x77bbccddeeff1122u, 9u))); |
| |
| constexpr uint8_t kTenByte[] = { |
| 0x80 | (0xffffffffffffffffu & 0x7f), 0x80 | ((0xffffffffffffffffu >> 7) & 0x7f), |
| 0x80 | ((0xffffffffffffffffu >> 14) & 0x7f), 0x80 | ((0xffffffffffffffffu >> 21) & 0x7f), |
| 0x80 | ((0xffffffffffffffffu >> 28) & 0x7f), 0x80 | ((0xffffffffffffffffu >> 35) & 0x7f), |
| 0x80 | ((0xffffffffffffffffu >> 42) & 0x7f), 0x80 | ((0xffffffffffffffffu >> 49) & 0x7f), |
| 0x80 | ((0xffffffffffffffffu >> 56) & 0x7f), ((0xffffffffffffffffu >> 63) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Uleb128::Read(AsBytes(kTenByte)), |
| Optional(FieldsAre(0xffffffffffffffffu, 10u))); |
| |
| constexpr uint8_t kTooManyBytes[17] = {0x80 | 23, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, |
| 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0}; |
| EXPECT_EQ(elfldltl::dwarf::Uleb128::Read(AsBytes(kTooManyBytes)), std::nullopt); |
| } |
| |
| TEST(ElfldltlDwarfTests, Sleb128) { |
| EXPECT_EQ(elfldltl::dwarf::Sleb128::Read(kNoBytes), std::nullopt); |
| |
| constexpr uint8_t kOneByte{17}; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kOneByte)), Optional(FieldsAre(17, 1u))); |
| |
| constexpr uint8_t kTwoByte[] = {0x80 | (0xaau & 0x7f), 0xaau >> 7}; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kTwoByte)), Optional(FieldsAre(0xaa, 2u))); |
| |
| constexpr uint8_t kThreeByte[] = { |
| 0x80 | (0xaabbu & 0x7f), |
| 0x80 | ((0xaabbu >> 7) & 0x7f), |
| ((0xaabbu >> 14) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kThreeByte)), Optional(FieldsAre(0xaabb, 3u))); |
| |
| constexpr uint8_t kFourByte[] = { |
| 0x80 | (0xaabbcc & 0x7f), |
| 0x80 | ((0xaabbcc >> 7) & 0x7f), |
| 0x80 | ((0xaabbcc >> 14) & 0x7f), |
| ((0xaabbcc >> 21) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kFourByte)), Optional(FieldsAre(0xaabbcc, 4))); |
| |
| constexpr uint8_t kFiveByte[] = { |
| 0x80 | (0xaabbccdd & 0x7f), 0x80 | ((0xaabbccdd >> 7) & 0x7f), |
| 0x80 | ((0xaabbccdd >> 14) & 0x7f), 0x80 | ((0xaabbccdd >> 21) & 0x7f), |
| ((0xaabbccdd >> 28) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kFiveByte)), |
| Optional(FieldsAre(0xaabbccdd, 5u))); |
| |
| constexpr uint8_t kSixByte[] = { |
| 0x80 | (0xaabbccddee & 0x7f), 0x80 | ((0xaabbccddee >> 7) & 0x7f), |
| 0x80 | ((0xaabbccddee >> 14) & 0x7f), 0x80 | ((0xaabbccddee >> 21) & 0x7f), |
| 0x80 | ((0xaabbccddee >> 28) & 0x7f), ((0xaabbccddee >> 35) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kSixByte)), |
| Optional(FieldsAre(0xaabbccddee, 6u))); |
| |
| constexpr uint8_t kSevenByte[] = { |
| 0x80 | (0xaabbccddeeff & 0x7f), 0x80 | ((0xaabbccddeeff >> 7) & 0x7f), |
| 0x80 | ((0xaabbccddeeff >> 14) & 0x7f), 0x80 | ((0xaabbccddeeff >> 21) & 0x7f), |
| 0x80 | ((0xaabbccddeeff >> 28) & 0x7f), 0x80 | ((0xaabbccddeeff >> 35) & 0x7f), |
| ((0xaabbccddeeff >> 42) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kSevenByte)), |
| Optional(FieldsAre(0xaabbccddeeff, 7u))); |
| |
| constexpr uint8_t kEightByte[] = { |
| 0x80 | (0x7abbccddeeff11 & 0x7f), 0x80 | ((0x7abbccddeeff11 >> 7) & 0x7f), |
| 0x80 | ((0x7abbccddeeff11 >> 14) & 0x7f), 0x80 | ((0x7abbccddeeff11 >> 21) & 0x7f), |
| 0x80 | ((0x7abbccddeeff11 >> 28) & 0x7f), 0x80 | ((0x7abbccddeeff11 >> 35) & 0x7f), |
| 0x80 | ((0x7abbccddeeff11 >> 42) & 0x7f), ((0x7abbccddeeff11 >> 49) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kEightByte)), |
| Optional(FieldsAre(0x7abbccddeeff11, 8u))); |
| |
| constexpr uint8_t kNineByte[] = { |
| 0x80 | (0x33bbccddeeff1122 & 0x7f), 0x80 | ((0x33bbccddeeff1122 >> 7) & 0x7f), |
| 0x80 | ((0x33bbccddeeff1122 >> 14) & 0x7f), 0x80 | ((0x33bbccddeeff1122 >> 21) & 0x7f), |
| 0x80 | ((0x33bbccddeeff1122 >> 28) & 0x7f), 0x80 | ((0x33bbccddeeff1122 >> 35) & 0x7f), |
| 0x80 | ((0x33bbccddeeff1122 >> 42) & 0x7f), 0x80 | ((0x33bbccddeeff1122 >> 49) & 0x7f), |
| ((0x33bbccddeeff1122 >> 56) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kNineByte)), |
| Optional(FieldsAre(0x33bbccddeeff1122, 9u))); |
| |
| constexpr uint8_t kOneByteNegative{-17 & 0x7f}; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kOneByteNegative)), |
| Optional(FieldsAre(-17, 1u))); |
| |
| constexpr uint8_t kTwoByteNegative[] = {0x80 | (-0xaa & 0x7f), (-0xaau >> 7) & 0x7f}; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kTwoByteNegative)), |
| Optional(FieldsAre(-0xaa, 2u))); |
| |
| constexpr uint8_t kThreeByteNegative[] = { |
| 0x80 | (-0xaabb & 0x7f), |
| 0x80 | ((-0xaabb >> 7) & 0x7f), |
| ((-0xaabb >> 14) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kThreeByteNegative)), |
| Optional(FieldsAre(-0xaabb, 3u))); |
| |
| constexpr uint8_t kFourByteNegative[] = { |
| 0x80 | (-0xaabbcc & 0x7f), |
| 0x80 | ((-0xaabbcc >> 7) & 0x7f), |
| 0x80 | ((-0xaabbcc >> 14) & 0x7f), |
| ((-0xaabbcc >> 21) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kFourByteNegative)), |
| Optional(FieldsAre(-0xaabbcc, 4))); |
| |
| constexpr uint8_t kFiveByteNegative[] = { |
| 0x80 | (-0xaabbccdd & 0x7f), 0x80 | ((-0xaabbccdd >> 7) & 0x7f), |
| 0x80 | ((-0xaabbccdd >> 14) & 0x7f), 0x80 | ((-0xaabbccdd >> 21) & 0x7f), |
| ((-0xaabbccdd >> 28) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kFiveByteNegative)), |
| Optional(FieldsAre(-0xaabbccdd, 5u))); |
| |
| constexpr uint8_t kSixByteNegative[] = { |
| 0x80 | (-0x33bbccddee & 0x7f), 0x80 | ((-0x33bbccddee >> 7) & 0x7f), |
| 0x80 | ((-0x33bbccddee >> 14) & 0x7f), 0x80 | ((-0x33bbccddee >> 21) & 0x7f), |
| 0x80 | ((-0x33bbccddee >> 28) & 0x7f), ((-0x33bbccddee >> 35) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kSixByteNegative)), |
| Optional(FieldsAre(-0x33bbccddee, 6u))); |
| |
| constexpr uint8_t kSevenByteNegative[] = { |
| 0x80 | (-0x33bbccddeeff & 0x7f), 0x80 | ((-0x33bbccddeeff >> 7) & 0x7f), |
| 0x80 | ((-0x33bbccddeeff >> 14) & 0x7f), 0x80 | ((-0x33bbccddeeff >> 21) & 0x7f), |
| 0x80 | ((-0x33bbccddeeff >> 28) & 0x7f), 0x80 | ((-0x33bbccddeeff >> 35) & 0x7f), |
| ((-0x33bbccddeeff >> 42) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kSevenByteNegative)), |
| Optional(FieldsAre(-0x33bbccddeeff, 7u))); |
| |
| constexpr uint8_t kEightByteNegative[] = { |
| 0x80 | (-0x7abbccddeeff11 & 0x7f), 0x80 | ((-0x7abbccddeeff11 >> 7) & 0x7f), |
| 0x80 | ((-0x7abbccddeeff11 >> 14) & 0x7f), 0x80 | ((-0x7abbccddeeff11 >> 21) & 0x7f), |
| 0x80 | ((-0x7abbccddeeff11 >> 28) & 0x7f), 0x80 | ((-0x7abbccddeeff11 >> 35) & 0x7f), |
| 0x80 | ((-0x7abbccddeeff11 >> 42) & 0x7f), ((-0x7abbccddeeff11 >> 49) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kEightByteNegative)), |
| Optional(FieldsAre(-0x7abbccddeeff11, 8u))); |
| |
| constexpr uint8_t kNineByteNegative[] = { |
| 0x80 | (-0x33bbccddeeff1122 & 0x7f), 0x80 | ((-0x33bbccddeeff1122 >> 7) & 0x7f), |
| 0x80 | ((-0x33bbccddeeff1122 >> 14) & 0x7f), 0x80 | ((-0x33bbccddeeff1122 >> 21) & 0x7f), |
| 0x80 | ((-0x33bbccddeeff1122 >> 28) & 0x7f), 0x80 | ((-0x33bbccddeeff1122 >> 35) & 0x7f), |
| 0x80 | ((-0x33bbccddeeff1122 >> 42) & 0x7f), 0x80 | ((-0x33bbccddeeff1122 >> 49) & 0x7f), |
| ((-0x33bbccddeeff1122 >> 56) & 0x7f), |
| }; |
| EXPECT_THAT(elfldltl::dwarf::Sleb128::Read(AsBytes(kNineByteNegative)), |
| Optional(FieldsAre(-0x33bbccddeeff1122, 9u))); |
| |
| constexpr uint8_t kTooManyBytes[17] = {0x80 | (-23 & 0x7f), |
| 0x80, |
| 0x80, |
| 0x80, |
| 0x80, |
| 0x80, |
| 0x80, |
| 0x80, |
| 0x80, |
| 0x80, |
| 0x80, |
| 0x80, |
| 0x80, |
| 0x80, |
| 0x80, |
| 0x80, |
| 0}; |
| EXPECT_EQ(elfldltl::dwarf::Sleb128::Read(AsBytes(kTooManyBytes)), std::nullopt); |
| } |
| |
| template <typename T> |
| constexpr uint8_t kSize = sizeof(T); |
| |
| TYPED_TEST(ElfldltlDwarfTests, EncodedPtr) { |
| using elfldltl::dwarf::EncodedPtr; |
| using Elf = typename TestFixture::Elf; |
| using Addr = typename Elf::Addr; |
| using Half = typename Elf::Half; |
| using Word = typename Elf::Word; |
| using Xword = typename Elf::Xword; |
| |
| EncodedPtr ptr; |
| EXPECT_EQ(ptr.ptr, 0u); |
| EXPECT_EQ(ptr.encoded_size, 0u); |
| EXPECT_EQ(ptr.encoding, EncodedPtr::kOmit); |
| EXPECT_EQ(EncodedPtr::Type(ptr.encoding), EncodedPtr::kOmit); |
| EXPECT_EQ(EncodedPtr::Modifier(ptr.encoding), EncodedPtr::kAbs); |
| EXPECT_FALSE(EncodedPtr::Signed(ptr.encoding)); |
| EXPECT_FALSE(EncodedPtr::Indirect(ptr.encoding)); |
| |
| EXPECT_EQ(EncodedPtr::Normalize<Elf>(EncodedPtr::kPtr), |
| kSize<Addr> == 4 ? EncodedPtr::kUdata4 : EncodedPtr::kUdata8); |
| |
| EXPECT_EQ(EncodedPtr::EncodedSize(EncodedPtr::kOmit, kSize<Addr>), 0u); |
| EXPECT_EQ(EncodedPtr::EncodedSize(EncodedPtr::kPtr, kSize<Addr>), kSize<Addr>); |
| EXPECT_EQ(EncodedPtr::EncodedSize(EncodedPtr::kSigned, kSize<Addr>), kSize<Addr>); |
| EXPECT_EQ(EncodedPtr::EncodedSize(EncodedPtr::kUdata2, kSize<Addr>), 2u); |
| EXPECT_EQ(EncodedPtr::EncodedSize(EncodedPtr::kUdata4, kSize<Addr>), 4u); |
| EXPECT_EQ(EncodedPtr::EncodedSize(EncodedPtr::kUdata8, kSize<Addr>), 8u); |
| EXPECT_EQ(EncodedPtr::EncodedSize(EncodedPtr::kSdata2, kSize<Addr>), 2u); |
| EXPECT_EQ(EncodedPtr::EncodedSize(EncodedPtr::kSdata4, kSize<Addr>), 4u); |
| EXPECT_EQ(EncodedPtr::EncodedSize(EncodedPtr::kSdata8, kSize<Addr>), 8u); |
| EXPECT_EQ(EncodedPtr::EncodedSize(EncodedPtr::kUleb128, kSize<Addr>), EncodedPtr::kDynamicSize); |
| EXPECT_EQ(EncodedPtr::EncodedSize(EncodedPtr::kSleb128, kSize<Addr>), EncodedPtr::kDynamicSize); |
| |
| EXPECT_EQ(EncodedPtr::Read<Elf>(EncodedPtr::kPtr, kNoBytes), std::nullopt); |
| |
| constexpr Addr addr = 0x12345678; |
| EXPECT_THAT( |
| EncodedPtr::Read<Elf>(EncodedPtr::kPtr, AsBytes(addr)), |
| Optional(AllOf(Field(&EncodedPtr::ptr, addr), Field(&EncodedPtr::encoding, EncodedPtr::kPtr), |
| Field(&EncodedPtr::encoded_size, kSize<Addr>)))); |
| |
| constexpr Half half = 0x1234; |
| EXPECT_THAT(EncodedPtr::Read<Elf>(EncodedPtr::kUdata2, AsBytes(half)), |
| Optional(AllOf(Field(&EncodedPtr::ptr, half), |
| Field(&EncodedPtr::encoding, EncodedPtr::kUdata2), |
| Field(&EncodedPtr::encoded_size, kSize<Half>)))); |
| |
| constexpr Word word = 0x12345678; |
| EXPECT_THAT(EncodedPtr::Read<Elf>(EncodedPtr::kUdata4, AsBytes(word)), |
| Optional(AllOf(Field(&EncodedPtr::ptr, word), |
| Field(&EncodedPtr::encoding, EncodedPtr::kUdata4), |
| Field(&EncodedPtr::encoded_size, kSize<Word>)))); |
| |
| constexpr Xword xword = 0x12345678abcdef12; |
| EXPECT_THAT(EncodedPtr::Read<Elf>(EncodedPtr::kUdata8, AsBytes(xword)), |
| Optional(AllOf(Field(&EncodedPtr::ptr, xword), |
| Field(&EncodedPtr::encoding, EncodedPtr::kUdata8), |
| Field(&EncodedPtr::encoded_size, kSize<Xword>)))); |
| |
| constexpr typename Half::Signed shalf = -0x1234; |
| EXPECT_THAT(EncodedPtr::Read<Elf>(EncodedPtr::kSdata2, AsBytes(shalf)), |
| Optional(AllOf(Field(&EncodedPtr::sptr, shalf), |
| Field(&EncodedPtr::encoding, EncodedPtr::kSdata2), |
| Field(&EncodedPtr::encoded_size, kSize<Half>)))); |
| |
| constexpr typename Word::Signed sword = -0x12345678; |
| EXPECT_THAT(EncodedPtr::Read<Elf>(EncodedPtr::kSdata4, AsBytes(sword)), |
| Optional(AllOf(Field(&EncodedPtr::sptr, sword), |
| Field(&EncodedPtr::encoding, EncodedPtr::kSdata4), |
| Field(&EncodedPtr::encoded_size, kSize<Word>)))); |
| |
| constexpr typename Xword::Signed sxword = -0x12345678abcdef12; |
| EXPECT_THAT(EncodedPtr::Read<Elf>(EncodedPtr::kSdata8, AsBytes(sxword)), |
| Optional(AllOf(Field(&EncodedPtr::sptr, sxword), |
| Field(&EncodedPtr::encoding, EncodedPtr::kSdata8), |
| Field(&EncodedPtr::encoded_size, kSize<Xword>)))); |
| |
| constexpr uint8_t kThreeByte[] = { |
| 0x80 | (0xaabbu & 0x7f), |
| 0x80 | ((0xaabbu >> 7) & 0x7f), |
| ((0xaabbu >> 14) & 0x7f), |
| }; |
| EXPECT_THAT(EncodedPtr::Read<Elf>(EncodedPtr::kUleb128, AsBytes(kThreeByte)), |
| Optional(AllOf(Field(&EncodedPtr::ptr, 0xaabbu), |
| Field(&EncodedPtr::encoding, EncodedPtr::kUleb128), |
| Field(&EncodedPtr::encoded_size, uint8_t{3})))); |
| |
| constexpr uint8_t kThreeByteNegative[] = { |
| 0x80 | (-0xaabb & 0x7f), |
| 0x80 | ((-0xaabb >> 7) & 0x7f), |
| ((-0xaabb >> 14) & 0x7f), |
| }; |
| EXPECT_THAT(EncodedPtr::Read<Elf>(EncodedPtr::kSleb128, AsBytes(kThreeByte)), |
| Optional(AllOf(Field(&EncodedPtr::ptr, 0xaabbu), |
| Field(&EncodedPtr::encoding, EncodedPtr::kSleb128), |
| Field(&EncodedPtr::encoded_size, uint8_t{3})))); |
| EXPECT_THAT(EncodedPtr::Read<Elf>(EncodedPtr::kSleb128, AsBytes(kThreeByteNegative)), |
| Optional(AllOf(Field(&EncodedPtr::ptr, -0xaabb), |
| Field(&EncodedPtr::encoding, EncodedPtr::kSleb128), |
| Field(&EncodedPtr::encoded_size, uint8_t{3})))); |
| } |
| |
| TYPED_TEST(ElfldltlDwarfTests, EncodedPtrFromMemory) { |
| using elfldltl::dwarf::EncodedPtr; |
| using Elf = typename TestFixture::Elf; |
| using Addr = typename Elf::Addr; |
| using size_type = typename Elf::size_type; |
| |
| static constexpr size_type kMemoryBase = 0x12345000; |
| static constexpr size_type kEncodedAt = 0x12345ea0; |
| static constexpr size_type kIndirectEncodedAt = 0x12345bb0; |
| static constexpr size_type kRelIndirectEncodedAt = 0x12345bc0; |
| static constexpr size_type kBadIndirectEncodedAt = 0x12345bd0; |
| static constexpr size_type kIndirectedTo = 0x12345120; |
| static constexpr size_type kDirectValue = 0xabcdef12; |
| static constexpr Addr kIndirectValue = 0x1234abcd; |
| static constexpr auto kData = []() { |
| std::array<Addr, 0x1000 / sizeof(Addr)> words{}; |
| for (Addr& word : words) { |
| word = 0xdeadbeef; |
| } |
| auto set = [&words](size_type addr, Addr value) { |
| words[(addr - kMemoryBase) / sizeof(Addr)] = value; |
| }; |
| set(kEncodedAt, kDirectValue); |
| set(kIndirectEncodedAt, kIndirectedTo); |
| set(kRelIndirectEncodedAt, kIndirectedTo - kRelIndirectEncodedAt); |
| set(kBadIndirectEncodedAt, 0xbad1230 - kBadIndirectEncodedAt); |
| set(kIndirectedTo, kIndirectValue); |
| return words; |
| }(); |
| const cpp20::span<std::byte> kImage{ |
| const_cast<std::byte*>(cpp20::as_bytes(cpp20::span{kData}).data()), |
| cpp20::span(kData).size_bytes(), |
| }; |
| |
| elfldltl::DirectMemory memory{kImage, kMemoryBase}; |
| |
| EXPECT_EQ(EncodedPtr::FromMemory<Elf>(EncodedPtr::kPtr, memory, 0xbad10000, kSize<Addr>), |
| std::nullopt); |
| |
| EXPECT_THAT(EncodedPtr::FromMemory<Elf>(EncodedPtr::kPtr, memory, kEncodedAt, kSize<Addr>), |
| Optional(kDirectValue)); |
| |
| EXPECT_THAT( |
| EncodedPtr::FromMemory<Elf>(static_cast<uint8_t>(EncodedPtr::kPtr) | EncodedPtr::kPcrel, |
| memory, kEncodedAt, kSize<Addr>), |
| Optional(kEncodedAt + kDirectValue)); |
| |
| EXPECT_THAT(EncodedPtr::FromMemory<Elf>(EncodedPtr::kPtr | EncodedPtr::kIndirect, memory, |
| kIndirectEncodedAt, kSize<Addr>), |
| Optional(kIndirectValue)); |
| |
| EXPECT_THAT( |
| EncodedPtr::FromMemory<Elf>(EncodedPtr::kPtr | EncodedPtr::kIndirect | EncodedPtr::kPcrel, |
| memory, kRelIndirectEncodedAt, kSize<Addr>), |
| Optional(kIndirectValue)); |
| |
| EXPECT_EQ(EncodedPtr::FromMemory<Elf>(EncodedPtr::kPtr | EncodedPtr::kIndirect, memory, |
| kBadIndirectEncodedAt, kSize<Addr>), |
| std::nullopt); |
| } |
| |
| TYPED_TEST(ElfldltlDwarfTests, EhFrameHdr) { |
| using Elf = typename TestFixture::Elf; |
| using size_type = typename Elf::size_type; |
| using Word = typename Elf::Word; |
| using Phdr = typename Elf::Phdr; |
| using value_type = elfldltl::dwarf::EhFrameHdrEntry<size_type>; |
| |
| elfldltl::dwarf::EhFrameHdr<Elf> eh_frame_hdr; |
| EXPECT_TRUE(eh_frame_hdr.empty()); |
| |
| auto diag = elfldltl::testing::ExpectOkDiagnostics(); |
| |
| constexpr std::array kEntries{ |
| value_type{0x1000, 0x370}, |
| value_type{0x1005, 0x3f0}, |
| value_type{0x1011, 0x46c}, |
| }; |
| |
| std::stringstream os; |
| for (const value_type& entry : kEntries) { |
| os << entry << "\n"; |
| } |
| EXPECT_EQ(os.str(), R"""([PC 0x1000 -> FDE 0x370] |
| [PC 0x1005 -> FDE 0x3f0] |
| [PC 0x1011 -> FDE 0x46c] |
| )"""); |
| |
| constexpr size_type kVaddr = 0x334; |
| constexpr size_type kEhFrameVaddr = 0x358; |
| static constexpr std::array<Word, 9> kData = { |
| Word{std::array{ |
| std::byte{0x01}, // version 1 |
| std::byte{0x1b}, // eh_frame_ptr sdata pcrel |
| std::byte{0x03}, // fde_count udata4 |
| std::byte{0x3b}, // fde_table sdata4 datarel |
| }}, |
| 0x20, // eh_frame_ptr |
| 3, // FDE count |
| 0xccc, |
| 0x3c, |
| 0xcd1, |
| 0xbc, |
| 0xcdd, |
| 0x138, |
| }; |
| const cpp20::span<std::byte> kImage{ |
| const_cast<std::byte*>(cpp20::as_bytes(cpp20::span{kData}).data()), |
| cpp20::span(kData).size_bytes(), |
| }; |
| |
| elfldltl::DirectMemory memory{kImage, kVaddr}; |
| |
| constexpr Phdr kPhdr = { |
| .type = elfldltl::ElfPhdrType::kEhFrameHdr, |
| .vaddr = kVaddr, |
| .filesz = sizeof(kData), |
| }; |
| |
| ASSERT_TRUE(eh_frame_hdr.Init(diag, memory, kPhdr)); |
| |
| EXPECT_EQ(eh_frame_hdr.eh_frame_ptr(), kEhFrameVaddr); |
| |
| EXPECT_EQ(eh_frame_hdr.size(), 3u); |
| |
| EXPECT_THAT(eh_frame_hdr, ElementsAreArray(kEntries)); |
| } |
| |
| constexpr uint32_t kFdeVaddr = 0x370; |
| |
| template <class Elf> |
| struct [[gnu::packed]] TestEhFrame { |
| using Addr = typename Elf::Addr; |
| using Word = typename Elf::Word; |
| |
| struct TestCie { |
| [[gnu::packed]] Word cie_id = elfldltl::dwarf::kEhFrameCieId; |
| uint8_t version = 1; |
| char augmentation[4] = "zLR"; |
| uint8_t code_alignment_factor = 1; |
| uint8_t data_alignment_factor = -8 & 0x7f; |
| uint8_t return_address_register = 16; |
| uint8_t augmentation_data[3] = {2, 0, 0x1b}; |
| uint8_t instructions[5] = {0x0c, 0x07, 0x08, 0x90, 0x01}; |
| }; |
| using CieData = TestData<InitialLength32<Elf>, TestCie>; |
| |
| struct TestFde { |
| [[gnu::packed]] Word cie_pointer = sizeof(CieData) + sizeof(Word); |
| [[gnu::packed]] Word initial_location = // sdata4 | pcrel encoded: |
| 0x1000 - // Absolute address. |
| (kFdeVaddr + // FDE start address. |
| sizeof(Word) + // Initial length |
| sizeof(Word)); // CIE_pointer |
| [[gnu::packed]] Word address_range = 5; |
| uint8_t augmentation_data_size = sizeof(Addr); |
| [[gnu::packed]] Addr lsda = 0x534c55; |
| uint8_t instructions[3] = {0x08, 0x00, 0}; |
| }; |
| using FdeData = TestData<InitialLength32<Elf>, TestFde>; |
| |
| [[gnu::packed]] CieData cie; |
| [[gnu::packed]] FdeData fde; |
| }; |
| |
| template <class Elf> |
| constexpr TestEhFrame<Elf> kTestEhFrame{}; |
| |
| TYPED_TEST(ElfldltlDwarfTests, CfiEntry) { |
| using Elf = typename TestFixture::Elf; |
| |
| auto diag = elfldltl::testing::ExpectOkDiagnostics(); |
| |
| cpp20::span kData = AsBytes(kTestEhFrame<Elf>); |
| const cpp20::span<std::byte> kImage{ |
| const_cast<std::byte*>(kData.data()), |
| cpp20::span(kData).size_bytes(), |
| }; |
| elfldltl::DirectMemory memory{kImage, 0x358}; |
| |
| auto fde = elfldltl::dwarf::CfiEntry::ReadEhFrameFromMemory<Elf>(diag, memory, kFdeVaddr); |
| ASSERT_TRUE(fde); |
| |
| auto cie = fde->template ReadEhFrameCieFromMemory<Elf>(diag, memory); |
| ASSERT_TRUE(cie); |
| |
| auto cie_info = cie->template DecodeCie<Elf>(diag, *fde->cie_pointer()); |
| ASSERT_TRUE(cie_info); |
| |
| EXPECT_EQ(cie_info->return_address_register, 16u); |
| EXPECT_EQ(cie_info->initial_instructions.size_bytes(), 5u); |
| EXPECT_FALSE(cie_info->signal_frame); |
| |
| auto fde_info = fde->template DecodeFde<Elf>(diag, kFdeVaddr, *cie_info); |
| ASSERT_TRUE(fde_info); |
| |
| EXPECT_EQ(fde_info->initial_location, 0x1000u); |
| EXPECT_EQ(fde_info->address_range, 5u); |
| EXPECT_EQ(fde_info->lsda, 0x534c55u); |
| EXPECT_EQ(fde_info->instructions.size_bytes(), 3u); |
| } |
| |
| } // namespace |
