1 //===- DWARFYAMLTest.cpp - Tests for DWARFYAML.cpp ------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "llvm/ObjectYAML/DWARFYAML.h"
10 #include "llvm/ObjectYAML/DWARFEmitter.h"
11 #include "llvm/Support/Error.h"
12 #include "llvm/Support/SourceMgr.h"
13 #include "llvm/Support/YAMLTraits.h"
14 #include "llvm/Testing/Support/Error.h"
15 #include "gtest/gtest.h"
16
17 using namespace llvm;
18
parseDWARFYAML(StringRef Yaml,T & Data)19 template <class T> static Error parseDWARFYAML(StringRef Yaml, T &Data) {
20 SMDiagnostic GenerateDiag;
21 yaml::Input YIn(
22 Yaml, /*Ctxt=*/nullptr,
23 [](const SMDiagnostic &Diag, void *DiagContext) {
24 *static_cast<SMDiagnostic *>(DiagContext) = Diag;
25 },
26 &GenerateDiag);
27
28 YIn >> Data;
29 if (YIn.error())
30 return createStringError(YIn.error(), GenerateDiag.getMessage());
31
32 return Error::success();
33 }
34
TEST(DebugAddrSection,TestParseDebugAddrYAML)35 TEST(DebugAddrSection, TestParseDebugAddrYAML) {
36 StringRef Yaml = R"(
37 debug_addr:
38 - Format: DWARF64
39 Length: 0x1234
40 Version: 5
41 )";
42 DWARFYAML::Data Data;
43 EXPECT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded());
44 }
45
TEST(DebugAddrSection,TestMissingVersion)46 TEST(DebugAddrSection, TestMissingVersion) {
47 StringRef Yaml = R"(
48 Format: DWARF64
49 Length: 0x1234
50 )";
51 DWARFYAML::AddrTableEntry AddrTableEntry;
52 EXPECT_THAT_ERROR(parseDWARFYAML(Yaml, AddrTableEntry),
53 FailedWithMessage("missing required key 'Version'"));
54 }
55
TEST(DebugAddrSection,TestUnexpectedKey)56 TEST(DebugAddrSection, TestUnexpectedKey) {
57 StringRef Yaml = R"(
58 Format: DWARF64
59 Length: 0x1234
60 Version: 5
61 Blah: unexpected
62 )";
63 DWARFYAML::AddrTableEntry AddrTableEntry;
64 EXPECT_THAT_ERROR(parseDWARFYAML(Yaml, AddrTableEntry),
65 FailedWithMessage("unknown key 'Blah'"));
66 }
67
TEST(DebugPubSection,TestDebugPubSection)68 TEST(DebugPubSection, TestDebugPubSection) {
69 StringRef Yaml = R"(
70 debug_pubnames:
71 Length: 0x1234
72 Version: 2
73 UnitOffset: 0x4321
74 UnitSize: 0x00
75 Entries:
76 - DieOffset: 0x1234
77 Name: abc
78 - DieOffset: 0x4321
79 Name: def
80 debug_pubtypes:
81 Length: 0x1234
82 Version: 2
83 UnitOffset: 0x4321
84 UnitSize: 0x00
85 Entries:
86 - DieOffset: 0x1234
87 Name: abc
88 - DieOffset: 0x4321
89 Name: def
90 )";
91 DWARFYAML::Data Data;
92 ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded());
93
94 ASSERT_TRUE(Data.PubNames.hasValue());
95 DWARFYAML::PubSection PubNames = Data.PubNames.getValue();
96
97 ASSERT_EQ(PubNames.Entries.size(), 2u);
98 EXPECT_EQ((uint32_t)PubNames.Entries[0].DieOffset, 0x1234u);
99 EXPECT_EQ(PubNames.Entries[0].Name, "abc");
100 EXPECT_EQ((uint32_t)PubNames.Entries[1].DieOffset, 0x4321u);
101 EXPECT_EQ(PubNames.Entries[1].Name, "def");
102
103 ASSERT_TRUE(Data.PubTypes.hasValue());
104 DWARFYAML::PubSection PubTypes = Data.PubTypes.getValue();
105
106 ASSERT_EQ(PubTypes.Entries.size(), 2u);
107 EXPECT_EQ((uint32_t)PubTypes.Entries[0].DieOffset, 0x1234u);
108 EXPECT_EQ(PubTypes.Entries[0].Name, "abc");
109 EXPECT_EQ((uint32_t)PubTypes.Entries[1].DieOffset, 0x4321u);
110 EXPECT_EQ(PubTypes.Entries[1].Name, "def");
111 }
112
TEST(DebugPubSection,TestUnexpectedDescriptor)113 TEST(DebugPubSection, TestUnexpectedDescriptor) {
114 StringRef Yaml = R"(
115 debug_pubnames:
116 Length: 0x1234
117 Version: 2
118 UnitOffset: 0x4321
119 UnitSize: 0x00
120 Entries:
121 - DieOffset: 0x1234
122 Descriptor: 0x12
123 Name: abcd
124 )";
125 DWARFYAML::Data Data;
126 EXPECT_THAT_ERROR(parseDWARFYAML(Yaml, Data),
127 FailedWithMessage("unknown key 'Descriptor'"));
128 }
129
TEST(DebugGNUPubSection,TestDebugGNUPubSections)130 TEST(DebugGNUPubSection, TestDebugGNUPubSections) {
131 StringRef Yaml = R"(
132 debug_gnu_pubnames:
133 Length: 0x1234
134 Version: 2
135 UnitOffset: 0x4321
136 UnitSize: 0x00
137 Entries:
138 - DieOffset: 0x1234
139 Descriptor: 0x12
140 Name: abc
141 - DieOffset: 0x4321
142 Descriptor: 0x34
143 Name: def
144 debug_gnu_pubtypes:
145 Length: 0x1234
146 Version: 2
147 UnitOffset: 0x4321
148 UnitSize: 0x00
149 Entries:
150 - DieOffset: 0x1234
151 Descriptor: 0x12
152 Name: abc
153 - DieOffset: 0x4321
154 Descriptor: 0x34
155 Name: def
156 )";
157 DWARFYAML::Data Data;
158 ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded());
159
160 ASSERT_TRUE(Data.GNUPubNames.hasValue());
161 DWARFYAML::PubSection GNUPubNames = Data.GNUPubNames.getValue();
162
163 ASSERT_EQ(GNUPubNames.Entries.size(), 2u);
164 EXPECT_EQ((uint32_t)GNUPubNames.Entries[0].DieOffset, 0x1234u);
165 EXPECT_EQ((uint8_t)GNUPubNames.Entries[0].Descriptor, 0x12);
166 EXPECT_EQ(GNUPubNames.Entries[0].Name, "abc");
167 EXPECT_EQ((uint32_t)GNUPubNames.Entries[1].DieOffset, 0x4321u);
168 EXPECT_EQ((uint8_t)GNUPubNames.Entries[1].Descriptor, 0x34);
169 EXPECT_EQ(GNUPubNames.Entries[1].Name, "def");
170
171 ASSERT_TRUE(Data.GNUPubTypes.hasValue());
172 DWARFYAML::PubSection GNUPubTypes = Data.GNUPubTypes.getValue();
173
174 ASSERT_EQ(GNUPubTypes.Entries.size(), 2u);
175 EXPECT_EQ((uint32_t)GNUPubTypes.Entries[0].DieOffset, 0x1234u);
176 EXPECT_EQ((uint8_t)GNUPubTypes.Entries[0].Descriptor, 0x12);
177 EXPECT_EQ(GNUPubTypes.Entries[0].Name, "abc");
178 EXPECT_EQ((uint32_t)GNUPubTypes.Entries[1].DieOffset, 0x4321u);
179 EXPECT_EQ((uint8_t)GNUPubTypes.Entries[1].Descriptor, 0x34);
180 EXPECT_EQ(GNUPubTypes.Entries[1].Name, "def");
181 }
182
TEST(DebugGNUPubSection,TestMissingDescriptor)183 TEST(DebugGNUPubSection, TestMissingDescriptor) {
184 StringRef Yaml = R"(
185 debug_gnu_pubnames:
186 Length: 0x1234
187 Version: 2
188 UnitOffset: 0x4321
189 UnitSize: 0x00
190 Entries:
191 - DieOffset: 0x1234
192 Name: abcd
193 )";
194 DWARFYAML::Data Data;
195 EXPECT_THAT_ERROR(parseDWARFYAML(Yaml, Data),
196 FailedWithMessage("missing required key 'Descriptor'"));
197 }
198