| //===- DWARFYAMLTest.cpp - Tests for DWARFYAML.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/ObjectYAML/DWARFYAML.h" |
| #include "llvm/ObjectYAML/DWARFEmitter.h" |
| #include "llvm/Support/Error.h" |
| #include "llvm/Support/SourceMgr.h" |
| #include "llvm/Support/YAMLTraits.h" |
| #include "llvm/Testing/Support/Error.h" |
| #include "gtest/gtest.h" |
| |
| using namespace llvm; |
| |
| template <class T> static Error parseDWARFYAML(StringRef Yaml, T &Data) { |
| SMDiagnostic GenerateDiag; |
| yaml::Input YIn( |
| Yaml, /*Ctxt=*/nullptr, |
| [](const SMDiagnostic &Diag, void *DiagContext) { |
| *static_cast<SMDiagnostic *>(DiagContext) = Diag; |
| }, |
| &GenerateDiag); |
| |
| YIn >> Data; |
| if (YIn.error()) |
| return createStringError(YIn.error(), GenerateDiag.getMessage()); |
| |
| return Error::success(); |
| } |
| |
| TEST(DebugAddrSection, TestParseDebugAddrYAML) { |
| StringRef Yaml = R"( |
| debug_addr: |
| - Format: DWARF64 |
| Length: 0x1234 |
| Version: 5 |
| )"; |
| DWARFYAML::Data Data; |
| EXPECT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded()); |
| } |
| |
| TEST(DebugAddrSection, TestMissingVersion) { |
| StringRef Yaml = R"( |
| Format: DWARF64 |
| Length: 0x1234 |
| )"; |
| DWARFYAML::AddrTableEntry AddrTableEntry; |
| EXPECT_THAT_ERROR(parseDWARFYAML(Yaml, AddrTableEntry), |
| FailedWithMessage("missing required key 'Version'")); |
| } |
| |
| TEST(DebugAddrSection, TestUnexpectedKey) { |
| StringRef Yaml = R"( |
| Format: DWARF64 |
| Length: 0x1234 |
| Version: 5 |
| Blah: unexpected |
| )"; |
| DWARFYAML::AddrTableEntry AddrTableEntry; |
| EXPECT_THAT_ERROR(parseDWARFYAML(Yaml, AddrTableEntry), |
| FailedWithMessage("unknown key 'Blah'")); |
| } |
| |
| TEST(DebugPubSection, TestDebugPubSection) { |
| StringRef Yaml = R"( |
| debug_pubnames: |
| Length: 0x1234 |
| Version: 2 |
| UnitOffset: 0x4321 |
| UnitSize: 0x00 |
| Entries: |
| - DieOffset: 0x1234 |
| Name: abc |
| - DieOffset: 0x4321 |
| Name: def |
| debug_pubtypes: |
| Length: 0x1234 |
| Version: 2 |
| UnitOffset: 0x4321 |
| UnitSize: 0x00 |
| Entries: |
| - DieOffset: 0x1234 |
| Name: abc |
| - DieOffset: 0x4321 |
| Name: def |
| )"; |
| DWARFYAML::Data Data; |
| ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded()); |
| |
| ASSERT_TRUE(Data.PubNames.hasValue()); |
| DWARFYAML::PubSection PubNames = Data.PubNames.getValue(); |
| |
| ASSERT_EQ(PubNames.Entries.size(), 2u); |
| EXPECT_EQ((uint32_t)PubNames.Entries[0].DieOffset, 0x1234u); |
| EXPECT_EQ(PubNames.Entries[0].Name, "abc"); |
| EXPECT_EQ((uint32_t)PubNames.Entries[1].DieOffset, 0x4321u); |
| EXPECT_EQ(PubNames.Entries[1].Name, "def"); |
| |
| ASSERT_TRUE(Data.PubTypes.hasValue()); |
| DWARFYAML::PubSection PubTypes = Data.PubTypes.getValue(); |
| |
| ASSERT_EQ(PubTypes.Entries.size(), 2u); |
| EXPECT_EQ((uint32_t)PubTypes.Entries[0].DieOffset, 0x1234u); |
| EXPECT_EQ(PubTypes.Entries[0].Name, "abc"); |
| EXPECT_EQ((uint32_t)PubTypes.Entries[1].DieOffset, 0x4321u); |
| EXPECT_EQ(PubTypes.Entries[1].Name, "def"); |
| } |
| |
| TEST(DebugPubSection, TestUnexpectedDescriptor) { |
| StringRef Yaml = R"( |
| debug_pubnames: |
| Length: 0x1234 |
| Version: 2 |
| UnitOffset: 0x4321 |
| UnitSize: 0x00 |
| Entries: |
| - DieOffset: 0x1234 |
| Descriptor: 0x12 |
| Name: abcd |
| )"; |
| DWARFYAML::Data Data; |
| EXPECT_THAT_ERROR(parseDWARFYAML(Yaml, Data), |
| FailedWithMessage("unknown key 'Descriptor'")); |
| } |
| |
| TEST(DebugGNUPubSection, TestDebugGNUPubSections) { |
| StringRef Yaml = R"( |
| debug_gnu_pubnames: |
| Length: 0x1234 |
| Version: 2 |
| UnitOffset: 0x4321 |
| UnitSize: 0x00 |
| Entries: |
| - DieOffset: 0x1234 |
| Descriptor: 0x12 |
| Name: abc |
| - DieOffset: 0x4321 |
| Descriptor: 0x34 |
| Name: def |
| debug_gnu_pubtypes: |
| Length: 0x1234 |
| Version: 2 |
| UnitOffset: 0x4321 |
| UnitSize: 0x00 |
| Entries: |
| - DieOffset: 0x1234 |
| Descriptor: 0x12 |
| Name: abc |
| - DieOffset: 0x4321 |
| Descriptor: 0x34 |
| Name: def |
| )"; |
| DWARFYAML::Data Data; |
| ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded()); |
| |
| ASSERT_TRUE(Data.GNUPubNames.hasValue()); |
| DWARFYAML::PubSection GNUPubNames = Data.GNUPubNames.getValue(); |
| |
| ASSERT_EQ(GNUPubNames.Entries.size(), 2u); |
| EXPECT_EQ((uint32_t)GNUPubNames.Entries[0].DieOffset, 0x1234u); |
| EXPECT_EQ((uint8_t)GNUPubNames.Entries[0].Descriptor, 0x12); |
| EXPECT_EQ(GNUPubNames.Entries[0].Name, "abc"); |
| EXPECT_EQ((uint32_t)GNUPubNames.Entries[1].DieOffset, 0x4321u); |
| EXPECT_EQ((uint8_t)GNUPubNames.Entries[1].Descriptor, 0x34); |
| EXPECT_EQ(GNUPubNames.Entries[1].Name, "def"); |
| |
| ASSERT_TRUE(Data.GNUPubTypes.hasValue()); |
| DWARFYAML::PubSection GNUPubTypes = Data.GNUPubTypes.getValue(); |
| |
| ASSERT_EQ(GNUPubTypes.Entries.size(), 2u); |
| EXPECT_EQ((uint32_t)GNUPubTypes.Entries[0].DieOffset, 0x1234u); |
| EXPECT_EQ((uint8_t)GNUPubTypes.Entries[0].Descriptor, 0x12); |
| EXPECT_EQ(GNUPubTypes.Entries[0].Name, "abc"); |
| EXPECT_EQ((uint32_t)GNUPubTypes.Entries[1].DieOffset, 0x4321u); |
| EXPECT_EQ((uint8_t)GNUPubTypes.Entries[1].Descriptor, 0x34); |
| EXPECT_EQ(GNUPubTypes.Entries[1].Name, "def"); |
| } |
| |
| TEST(DebugGNUPubSection, TestMissingDescriptor) { |
| StringRef Yaml = R"( |
| debug_gnu_pubnames: |
| Length: 0x1234 |
| Version: 2 |
| UnitOffset: 0x4321 |
| UnitSize: 0x00 |
| Entries: |
| - DieOffset: 0x1234 |
| Name: abcd |
| )"; |
| DWARFYAML::Data Data; |
| EXPECT_THAT_ERROR(parseDWARFYAML(Yaml, Data), |
| FailedWithMessage("missing required key 'Descriptor'")); |
| } |