Debian Codegraph @

llvm-project/llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

raw
1 //===- llvm/unittest/DebugInfo/DWARFDebugInfoTest.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 "DwarfGenerator.h"
10 #include "DwarfUtils.h"
11 #include "llvm/ADT/ArrayRef.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/StringRef.h"
14 #include "llvm/ADT/Triple.h"
15 #include "llvm/BinaryFormat/Dwarf.h"
16 #include "llvm/CodeGen/AsmPrinter.h"
17 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
18 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
19 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
20 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
21 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
22 #include "llvm/DebugInfo/DWARF/DWARFVerifier.h"
23 #include "llvm/MC/MCContext.h"
24 #include "llvm/MC/MCSectionELF.h"
25 #include "llvm/MC/MCStreamer.h"
26 #include "llvm/MC/TargetRegistry.h"
27 #include "llvm/Object/ObjectFile.h"
28 #include "llvm/ObjectYAML/DWARFEmitter.h"
29 #include "llvm/Support/Error.h"
30 #include "llvm/Support/MemoryBuffer.h"
31 #include "llvm/Support/TargetSelect.h"
32 #include "llvm/Testing/Support/Error.h"
33 #include "gtest/gtest.h"
34 #include <string>
35
36 using namespace llvm;
37 using namespace dwarf;
38 using namespace utils;
39 using ::testing::HasSubstr;
40
41 namespace {
42
43 template <uint16_t Version, class AddrType, class RefAddrType>
44 void TestAllForms() {
45 Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
46 if (!isConfigurationSupported(Triple))
47 GTEST_SKIP();
48
49 // Test that we can decode all DW_FORM values correctly.
50 const AddrType AddrValue = (AddrType)0x0123456789abcdefULL;
51 const uint8_t BlockData[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
52 const uint32_t BlockSize = sizeof(BlockData);
53 const RefAddrType RefAddr = 0x12345678;
54 const uint8_t Data1 = 0x01U;
55 const uint16_t Data2 = 0x2345U;
56 const uint32_t Data4 = 0x6789abcdU;
57 const uint64_t Data8 = 0x0011223344556677ULL;
58 const uint64_t Data8_2 = 0xAABBCCDDEEFF0011ULL;
59 const uint8_t Data16[16] = {1, 2, 3, 4, 5, 6, 7, 8,
60 9, 10, 11, 12, 13, 14, 15, 16};
61 const int64_t SData = INT64_MIN;
62 const int64_t ICSData = INT64_MAX; // DW_FORM_implicit_const SData
63 const uint64_t UData[] = {UINT64_MAX - 1, UINT64_MAX - 2, UINT64_MAX - 3,
64 UINT64_MAX - 4, UINT64_MAX - 5, UINT64_MAX - 6,
65 UINT64_MAX - 7, UINT64_MAX - 8, UINT64_MAX - 9};
66 #define UDATA_1 18446744073709551614ULL
67 const uint32_t Dwarf32Values[] = {1, 2, 3, 4, 5, 6, 7, 8};
68 const char *StringValue = "Hello";
69 const char *StrpValue = "World";
70 const char *StrxValue = "Indexed";
71 const char *Strx1Value = "Indexed1";
72 const char *Strx2Value = "Indexed2";
73 const char *Strx3Value = "Indexed3";
74 const char *Strx4Value = "Indexed4";
75
76 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
77 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
78 dwarfgen::Generator *DG = ExpectedDG.get().get();
79 dwarfgen::CompileUnit &CU = DG->addCompileUnit();
80 dwarfgen::DIE CUDie = CU.getUnitDIE();
81
82 if (Version >= 5)
83 CUDie.addStrOffsetsBaseAttribute();
84
85 uint16_t Attr = DW_AT_lo_user;
86
87 //----------------------------------------------------------------------
88 // Test address forms
89 //----------------------------------------------------------------------
90 const auto Attr_DW_FORM_addr = static_cast<dwarf::Attribute>(Attr++);
91 CUDie.addAttribute(Attr_DW_FORM_addr, DW_FORM_addr, AddrValue);
92
93 //----------------------------------------------------------------------
94 // Test block forms
95 //----------------------------------------------------------------------
96 const auto Attr_DW_FORM_block = static_cast<dwarf::Attribute>(Attr++);
97 CUDie.addAttribute(Attr_DW_FORM_block, DW_FORM_block, BlockData, BlockSize);
98
99 const auto Attr_DW_FORM_block1 = static_cast<dwarf::Attribute>(Attr++);
100 CUDie.addAttribute(Attr_DW_FORM_block1, DW_FORM_block1, BlockData, BlockSize);
101
102 const auto Attr_DW_FORM_block2 = static_cast<dwarf::Attribute>(Attr++);
103 CUDie.addAttribute(Attr_DW_FORM_block2, DW_FORM_block2, BlockData, BlockSize);
104
105 const auto Attr_DW_FORM_block4 = static_cast<dwarf::Attribute>(Attr++);
106 CUDie.addAttribute(Attr_DW_FORM_block4, DW_FORM_block4, BlockData, BlockSize);
107
108 // We handle data16 as a block form.
109 const auto Attr_DW_FORM_data16 = static_cast<dwarf::Attribute>(Attr++);
110 if (Version >= 5)
111 CUDie.addAttribute(Attr_DW_FORM_data16, DW_FORM_data16, Data16, 16);
112
113 //----------------------------------------------------------------------
114 // Test data forms
115 //----------------------------------------------------------------------
116 const auto Attr_DW_FORM_data1 = static_cast<dwarf::Attribute>(Attr++);
117 CUDie.addAttribute(Attr_DW_FORM_data1, DW_FORM_data1, Data1);
118
119 const auto Attr_DW_FORM_data2 = static_cast<dwarf::Attribute>(Attr++);
120 CUDie.addAttribute(Attr_DW_FORM_data2, DW_FORM_data2, Data2);
121
122 const auto Attr_DW_FORM_data4 = static_cast<dwarf::Attribute>(Attr++);
123 CUDie.addAttribute(Attr_DW_FORM_data4, DW_FORM_data4, Data4);
124
125 const auto Attr_DW_FORM_data8 = static_cast<dwarf::Attribute>(Attr++);
126 CUDie.addAttribute(Attr_DW_FORM_data8, DW_FORM_data8, Data8);
127
128 //----------------------------------------------------------------------
129 // Test string forms
130 //----------------------------------------------------------------------
131 const auto Attr_DW_FORM_string = static_cast<dwarf::Attribute>(Attr++);
132 CUDie.addAttribute(Attr_DW_FORM_string, DW_FORM_string, StringValue);
133
134 const auto Attr_DW_FORM_strx = static_cast<dwarf::Attribute>(Attr++);
135 const auto Attr_DW_FORM_strx1 = static_cast<dwarf::Attribute>(Attr++);
136 const auto Attr_DW_FORM_strx2 = static_cast<dwarf::Attribute>(Attr++);
137 const auto Attr_DW_FORM_strx3 = static_cast<dwarf::Attribute>(Attr++);
138 const auto Attr_DW_FORM_strx4 = static_cast<dwarf::Attribute>(Attr++);
139 if (Version >= 5) {
140 CUDie.addAttribute(Attr_DW_FORM_strx, DW_FORM_strx, StrxValue);
141 CUDie.addAttribute(Attr_DW_FORM_strx1, DW_FORM_strx1, Strx1Value);
142 CUDie.addAttribute(Attr_DW_FORM_strx2, DW_FORM_strx2, Strx2Value);
143 CUDie.addAttribute(Attr_DW_FORM_strx3, DW_FORM_strx3, Strx3Value);
144 CUDie.addAttribute(Attr_DW_FORM_strx4, DW_FORM_strx4, Strx4Value);
145 }
146
147 const auto Attr_DW_FORM_strp = static_cast<dwarf::Attribute>(Attr++);
148 CUDie.addAttribute(Attr_DW_FORM_strp, DW_FORM_strp, StrpValue);
149
150 //----------------------------------------------------------------------
151 // Test reference forms
152 //----------------------------------------------------------------------
153 const auto Attr_DW_FORM_ref_addr = static_cast<dwarf::Attribute>(Attr++);
154 CUDie.addAttribute(Attr_DW_FORM_ref_addr, DW_FORM_ref_addr, RefAddr);
155
156 const auto Attr_DW_FORM_ref1 = static_cast<dwarf::Attribute>(Attr++);
157 CUDie.addAttribute(Attr_DW_FORM_ref1, DW_FORM_ref1, Data1);
158
159 const auto Attr_DW_FORM_ref2 = static_cast<dwarf::Attribute>(Attr++);
160 CUDie.addAttribute(Attr_DW_FORM_ref2, DW_FORM_ref2, Data2);
161
162 const auto Attr_DW_FORM_ref4 = static_cast<dwarf::Attribute>(Attr++);
163 CUDie.addAttribute(Attr_DW_FORM_ref4, DW_FORM_ref4, Data4);
164
165 const auto Attr_DW_FORM_ref8 = static_cast<dwarf::Attribute>(Attr++);
166 CUDie.addAttribute(Attr_DW_FORM_ref8, DW_FORM_ref8, Data8);
167
168 const auto Attr_DW_FORM_ref_sig8 = static_cast<dwarf::Attribute>(Attr++);
169 if (Version >= 4)
170 CUDie.addAttribute(Attr_DW_FORM_ref_sig8, DW_FORM_ref_sig8, Data8_2);
171
172 const auto Attr_DW_FORM_ref_udata = static_cast<dwarf::Attribute>(Attr++);
173 CUDie.addAttribute(Attr_DW_FORM_ref_udata, DW_FORM_ref_udata, UData[0]);
174
175 //----------------------------------------------------------------------
176 // Test flag forms
177 //----------------------------------------------------------------------
178 const auto Attr_DW_FORM_flag_true = static_cast<dwarf::Attribute>(Attr++);
179 CUDie.addAttribute(Attr_DW_FORM_flag_true, DW_FORM_flag, true);
180
181 const auto Attr_DW_FORM_flag_false = static_cast<dwarf::Attribute>(Attr++);
182 CUDie.addAttribute(Attr_DW_FORM_flag_false, DW_FORM_flag, false);
183
184 const auto Attr_DW_FORM_flag_present = static_cast<dwarf::Attribute>(Attr++);
185 if (Version >= 4)
186 CUDie.addAttribute(Attr_DW_FORM_flag_present, DW_FORM_flag_present);
187
188 //----------------------------------------------------------------------
189 // Test SLEB128 based forms
190 //----------------------------------------------------------------------
191 const auto Attr_DW_FORM_sdata = static_cast<dwarf::Attribute>(Attr++);
192 CUDie.addAttribute(Attr_DW_FORM_sdata, DW_FORM_sdata, SData);
193
194 const auto Attr_DW_FORM_implicit_const =
195 static_cast<dwarf::Attribute>(Attr++);
196 if (Version >= 5)
197 CUDie.addAttribute(Attr_DW_FORM_implicit_const, DW_FORM_implicit_const,
198 ICSData);
199
200 //----------------------------------------------------------------------
201 // Test ULEB128 based forms
202 //----------------------------------------------------------------------
203 const auto Attr_DW_FORM_udata = static_cast<dwarf::Attribute>(Attr++);
204 CUDie.addAttribute(Attr_DW_FORM_udata, DW_FORM_udata, UData[0]);
205
206 //----------------------------------------------------------------------
207 // Test DWARF32/DWARF64 forms
208 //----------------------------------------------------------------------
209 const auto Attr_DW_FORM_GNU_ref_alt = static_cast<dwarf::Attribute>(Attr++);
210 CUDie.addAttribute(Attr_DW_FORM_GNU_ref_alt, DW_FORM_GNU_ref_alt,
211 Dwarf32Values[0]);
212
213 const auto Attr_DW_FORM_sec_offset = static_cast<dwarf::Attribute>(Attr++);
214 if (Version >= 4)
215 CUDie.addAttribute(Attr_DW_FORM_sec_offset, DW_FORM_sec_offset,
216 Dwarf32Values[1]);
217
218 //----------------------------------------------------------------------
219 // Add an address at the end to make sure we can decode this value
220 //----------------------------------------------------------------------
221 const auto Attr_Last = static_cast<dwarf::Attribute>(Attr++);
222 CUDie.addAttribute(Attr_Last, DW_FORM_addr, AddrValue);
223
224 //----------------------------------------------------------------------
225 // Generate the DWARF
226 //----------------------------------------------------------------------
227 StringRef FileBytes = DG->generate();
228 MemoryBufferRef FileBuffer(FileBytes, "dwarf");
229 auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
230 EXPECT_TRUE((bool)Obj);
231 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
232 uint32_t NumCUs = DwarfContext->getNumCompileUnits();
233 EXPECT_EQ(NumCUs, 1u);
234 DWARFCompileUnit *U =
235 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0));
236 auto DieDG = U->getUnitDIE(false);
237 EXPECT_TRUE(DieDG.isValid());
238
239 //----------------------------------------------------------------------
240 // Test address forms
241 //----------------------------------------------------------------------
242 EXPECT_EQ(AddrValue, toAddress(DieDG.find(Attr_DW_FORM_addr), 0));
243
244 //----------------------------------------------------------------------
245 // Test block forms
246 //----------------------------------------------------------------------
247 std::optional<DWARFFormValue> FormValue;
248 ArrayRef<uint8_t> ExtractedBlockData;
249 std::optional<ArrayRef<uint8_t>> BlockDataOpt;
250
251 FormValue = DieDG.find(Attr_DW_FORM_block);
252 EXPECT_TRUE((bool)FormValue);
253 BlockDataOpt = FormValue->getAsBlock();
254 EXPECT_TRUE(BlockDataOpt.has_value());
255 ExtractedBlockData = *BlockDataOpt;
256 EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
257 EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
258
259 FormValue = DieDG.find(Attr_DW_FORM_block1);
260 EXPECT_TRUE((bool)FormValue);
261 BlockDataOpt = FormValue->getAsBlock();
262 EXPECT_TRUE(BlockDataOpt.has_value());
263 ExtractedBlockData = *BlockDataOpt;
264 EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
265 EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
266
267 FormValue = DieDG.find(Attr_DW_FORM_block2);
268 EXPECT_TRUE((bool)FormValue);
269 BlockDataOpt = FormValue->getAsBlock();
270 EXPECT_TRUE(BlockDataOpt.has_value());
271 ExtractedBlockData = *BlockDataOpt;
272 EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
273 EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
274
275 FormValue = DieDG.find(Attr_DW_FORM_block4);
276 EXPECT_TRUE((bool)FormValue);
277 BlockDataOpt = FormValue->getAsBlock();
278 EXPECT_TRUE(BlockDataOpt.has_value());
279 ExtractedBlockData = *BlockDataOpt;
280 EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
281 EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
282
283 // Data16 is handled like a block.
284 if (Version >= 5) {
285 FormValue = DieDG.find(Attr_DW_FORM_data16);
286 EXPECT_TRUE((bool)FormValue);
287 BlockDataOpt = FormValue->getAsBlock();
288 EXPECT_TRUE(BlockDataOpt.has_value());
289 ExtractedBlockData = *BlockDataOpt;
290 EXPECT_EQ(ExtractedBlockData.size(), 16u);
291 EXPECT_TRUE(memcmp(ExtractedBlockData.data(), Data16, 16) == 0);
292 }
293
294 //----------------------------------------------------------------------
295 // Test data forms
296 //----------------------------------------------------------------------
297 EXPECT_EQ(Data1, toUnsigned(DieDG.find(Attr_DW_FORM_data1), 0));
298 EXPECT_EQ(Data2, toUnsigned(DieDG.find(Attr_DW_FORM_data2), 0));
299 EXPECT_EQ(Data4, toUnsigned(DieDG.find(Attr_DW_FORM_data4), 0));
300 EXPECT_EQ(Data8, toUnsigned(DieDG.find(Attr_DW_FORM_data8), 0));
301
302 //----------------------------------------------------------------------
303 // Test string forms
304 //----------------------------------------------------------------------
305 auto ExtractedStringValue = toString(DieDG.find(Attr_DW_FORM_string));
306 EXPECT_TRUE((bool)ExtractedStringValue);
307 EXPECT_STREQ(StringValue, *ExtractedStringValue);
308
309 if (Version >= 5) {
310 auto ExtractedStrxValue = toString(DieDG.find(Attr_DW_FORM_strx));
311 EXPECT_TRUE((bool)ExtractedStrxValue);
312 EXPECT_STREQ(StrxValue, *ExtractedStrxValue);
313
314 auto ExtractedStrx1Value = toString(DieDG.find(Attr_DW_FORM_strx1));
315 EXPECT_TRUE((bool)ExtractedStrx1Value);
316 EXPECT_STREQ(Strx1Value, *ExtractedStrx1Value);
317
318 auto ExtractedStrx2Value = toString(DieDG.find(Attr_DW_FORM_strx2));
319 EXPECT_TRUE((bool)ExtractedStrx2Value);
320 EXPECT_STREQ(Strx2Value, *ExtractedStrx2Value);
321
322 auto ExtractedStrx3Value = toString(DieDG.find(Attr_DW_FORM_strx3));
323 EXPECT_TRUE((bool)ExtractedStrx3Value);
324 EXPECT_STREQ(Strx3Value, *ExtractedStrx3Value);
325
326 auto ExtractedStrx4Value = toString(DieDG.find(Attr_DW_FORM_strx4));
327 EXPECT_TRUE((bool)ExtractedStrx4Value);
328 EXPECT_STREQ(Strx4Value, *ExtractedStrx4Value);
329 }
330
331 auto ExtractedStrpValue = toString(DieDG.find(Attr_DW_FORM_strp));
332 EXPECT_TRUE((bool)ExtractedStrpValue);
333 EXPECT_STREQ(StrpValue, *ExtractedStrpValue);
334
335 //----------------------------------------------------------------------
336 // Test reference forms
337 //----------------------------------------------------------------------
338 EXPECT_EQ(RefAddr, toReference(DieDG.find(Attr_DW_FORM_ref_addr), 0));
339 EXPECT_EQ(Data1, toReference(DieDG.find(Attr_DW_FORM_ref1), 0));
340 EXPECT_EQ(Data2, toReference(DieDG.find(Attr_DW_FORM_ref2), 0));
341 EXPECT_EQ(Data4, toReference(DieDG.find(Attr_DW_FORM_ref4), 0));
342 EXPECT_EQ(Data8, toReference(DieDG.find(Attr_DW_FORM_ref8), 0));
343 if (Version >= 4) {
344 EXPECT_EQ(Data8_2, toReference(DieDG.find(Attr_DW_FORM_ref_sig8), 0));
345 }
346 EXPECT_EQ(UData[0], toReference(DieDG.find(Attr_DW_FORM_ref_udata), 0));
347
348 //----------------------------------------------------------------------
349 // Test flag forms
350 //----------------------------------------------------------------------
351 EXPECT_EQ(1ULL, toUnsigned(DieDG.find(Attr_DW_FORM_flag_true), 0));
352 EXPECT_EQ(0ULL, toUnsigned(DieDG.find(Attr_DW_FORM_flag_false), 1));
353 if (Version >= 4) {
354 EXPECT_EQ(1ULL, toUnsigned(DieDG.find(Attr_DW_FORM_flag_present), 0));
355 }
356
357 //----------------------------------------------------------------------
358 // Test SLEB128 based forms
359 //----------------------------------------------------------------------
360 EXPECT_EQ(SData, toSigned(DieDG.find(Attr_DW_FORM_sdata), 0));
361 if (Version >= 5) {
362 EXPECT_EQ(ICSData, toSigned(DieDG.find(Attr_DW_FORM_implicit_const), 0));
363 }
364
365 //----------------------------------------------------------------------
366 // Test ULEB128 based forms
367 //----------------------------------------------------------------------
368 EXPECT_EQ(UData[0], toUnsigned(DieDG.find(Attr_DW_FORM_udata), 0));
369
370 //----------------------------------------------------------------------
371 // Test DWARF32/DWARF64 forms
372 //----------------------------------------------------------------------
373 EXPECT_EQ(Dwarf32Values[0],
374 toReference(DieDG.find(Attr_DW_FORM_GNU_ref_alt), 0));
375 if (Version >= 4) {
376 EXPECT_EQ(Dwarf32Values[1],
377 toSectionOffset(DieDG.find(Attr_DW_FORM_sec_offset), 0));
378 }
379
380 //----------------------------------------------------------------------
381 // Add an address at the end to make sure we can decode this value
382 //----------------------------------------------------------------------
383 EXPECT_EQ(AddrValue, toAddress(DieDG.find(Attr_Last), 0));
384 }
385
386 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4AllForms) {
387 // Test that we can decode all forms for DWARF32, version 2, with 4 byte
388 // addresses.
389 typedef uint32_t AddrType;
390 // DW_FORM_ref_addr are the same as the address type in DWARF32 version 2.
391 typedef AddrType RefAddrType;
392 TestAllForms<2, AddrType, RefAddrType>();
393 }
394
395 #ifdef _AIX
396 TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version2Addr8AllForms) {
397 #else
398 TEST(DWARFDebugInfo, TestDWARF32Version2Addr8AllForms) {
399 #endif
400 // Test that we can decode all forms for DWARF32, version 2, with 4 byte
401 // addresses.
402 typedef uint64_t AddrType;
403 // DW_FORM_ref_addr are the same as the address type in DWARF32 version 2.
404 typedef AddrType RefAddrType;
405 TestAllForms<2, AddrType, RefAddrType>();
406 }
407
408 TEST(DWARFDebugInfo, TestDWARF32Version3Addr4AllForms) {
409 // Test that we can decode all forms for DWARF32, version 3, with 4 byte
410 // addresses.
411 typedef uint32_t AddrType;
412 // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later.
413 typedef uint32_t RefAddrType;
414 TestAllForms<3, AddrType, RefAddrType>();
415 }
416
417 #ifdef _AIX
418 TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version3Addr8AllForms) {
419 #else
420 TEST(DWARFDebugInfo, TestDWARF32Version3Addr8AllForms) {
421 #endif
422 // Test that we can decode all forms for DWARF32, version 3, with 8 byte
423 // addresses.
424 typedef uint64_t AddrType;
425 // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
426 typedef uint32_t RefAddrType;
427 TestAllForms<3, AddrType, RefAddrType>();
428 }
429
430 TEST(DWARFDebugInfo, TestDWARF32Version4Addr4AllForms) {
431 // Test that we can decode all forms for DWARF32, version 4, with 4 byte
432 // addresses.
433 typedef uint32_t AddrType;
434 // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
435 typedef uint32_t RefAddrType;
436 TestAllForms<4, AddrType, RefAddrType>();
437 }
438
439 #ifdef _AIX
440 TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version4Addr8AllForms) {
441 #else
442 TEST(DWARFDebugInfo, TestDWARF32Version4Addr8AllForms) {
443 #endif
444 // Test that we can decode all forms for DWARF32, version 4, with 8 byte
445 // addresses.
446 typedef uint64_t AddrType;
447 // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
448 typedef uint32_t RefAddrType;
449 TestAllForms<4, AddrType, RefAddrType>();
450 }
451
452 #ifdef _AIX
453 TEST(DWARFDebigInfo, DISABLED_TestDWARF32Version5Addr4AllForms) {
454 #else
455 TEST(DWARFDebugInfo, TestDWARF32Version5Addr4AllForms) {
456 #endif
457 // Test that we can decode all forms for DWARF32, version 5, with 4 byte
458 // addresses.
459 typedef uint32_t AddrType;
460 // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
461 typedef uint32_t RefAddrType;
462 TestAllForms<5, AddrType, RefAddrType>();
463 }
464
465 #ifdef _AIX
466 TEST(DWARFDebigInfo, DISABLED_TestDWARF32Version5Addr8AllForms) {
467 #else
468 TEST(DWARFDebugInfo, TestDWARF32Version5Addr8AllForms) {
469 #endif
470 // Test that we can decode all forms for DWARF32, version 5, with 8 byte
471 // addresses.
472 typedef uint64_t AddrType;
473 // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later
474 typedef uint32_t RefAddrType;
475 TestAllForms<5, AddrType, RefAddrType>();
476 }
477
478 template <uint16_t Version, class AddrType> void TestChildren() {
479 Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
480 if (!isConfigurationSupported(Triple))
481 GTEST_SKIP();
482
483 // Test that we can decode DW_FORM_ref_addr values correctly in DWARF 2 with
484 // 4 byte addresses. DW_FORM_ref_addr values should be 4 bytes when using
485 // 8 byte addresses.
486
487 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
488 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
489 dwarfgen::Generator *DG = ExpectedDG.get().get();
490 dwarfgen::CompileUnit &CU = DG->addCompileUnit();
491 dwarfgen::DIE CUDie = CU.getUnitDIE();
492
493 CUDie.addAttribute(DW_AT_name, DW_FORM_strp, "/tmp/main.c");
494 CUDie.addAttribute(DW_AT_language, DW_FORM_data2, DW_LANG_C);
495
496 dwarfgen::DIE SubprogramDie = CUDie.addChild(DW_TAG_subprogram);
497 SubprogramDie.addAttribute(DW_AT_name, DW_FORM_strp, "main");
498 SubprogramDie.addAttribute(DW_AT_low_pc, DW_FORM_addr, 0x1000U);
499 SubprogramDie.addAttribute(DW_AT_high_pc, DW_FORM_addr, 0x2000U);
500
501 dwarfgen::DIE IntDie = CUDie.addChild(DW_TAG_base_type);
502 IntDie.addAttribute(DW_AT_name, DW_FORM_strp, "int");
503 IntDie.addAttribute(DW_AT_encoding, DW_FORM_data1, DW_ATE_signed);
504 IntDie.addAttribute(DW_AT_byte_size, DW_FORM_data1, 4);
505
506 dwarfgen::DIE ArgcDie = SubprogramDie.addChild(DW_TAG_formal_parameter);
507 ArgcDie.addAttribute(DW_AT_name, DW_FORM_strp, "argc");
508 // ArgcDie.addAttribute(DW_AT_type, DW_FORM_ref4, IntDie);
509 ArgcDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, IntDie);
510
511 StringRef FileBytes = DG->generate();
512 MemoryBufferRef FileBuffer(FileBytes, "dwarf");
513 auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
514 EXPECT_TRUE((bool)Obj);
515 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
516
517 // Verify the number of compile units is correct.
518 uint32_t NumCUs = DwarfContext->getNumCompileUnits();
519 EXPECT_EQ(NumCUs, 1u);
520 DWARFCompileUnit *U =
521 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0));
522
523 // Get the compile unit DIE is valid.
524 auto DieDG = U->getUnitDIE(false);
525 EXPECT_TRUE(DieDG.isValid());
526
527 // Verify the first child of the compile unit DIE is our subprogram.
528 auto SubprogramDieDG = DieDG.getFirstChild();
529 EXPECT_TRUE(SubprogramDieDG.isValid());
530 EXPECT_EQ(SubprogramDieDG.getTag(), DW_TAG_subprogram);
531
532 // Verify the first child of the subprogram is our formal parameter.
533 auto ArgcDieDG = SubprogramDieDG.getFirstChild();
534 EXPECT_TRUE(ArgcDieDG.isValid());
535 EXPECT_EQ(ArgcDieDG.getTag(), DW_TAG_formal_parameter);
536
537 // Verify our formal parameter has a NULL tag sibling.
538 auto NullDieDG = ArgcDieDG.getSibling();
539 EXPECT_TRUE(NullDieDG.isValid());
540 if (NullDieDG) {
541 EXPECT_EQ(NullDieDG.getTag(), DW_TAG_null);
542 EXPECT_TRUE(!NullDieDG.getSibling().isValid());
543 EXPECT_TRUE(!NullDieDG.getFirstChild().isValid());
544 }
545
546 // Verify the sibling of our subprogram is our integer base type.
547 auto IntDieDG = SubprogramDieDG.getSibling();
548 EXPECT_TRUE(IntDieDG.isValid());
549 EXPECT_EQ(IntDieDG.getTag(), DW_TAG_base_type);
550
551 // Verify the sibling of our subprogram is our integer base is a NULL tag.
552 NullDieDG = IntDieDG.getSibling();
553 EXPECT_TRUE(NullDieDG.isValid());
554 if (NullDieDG) {
555 EXPECT_EQ(NullDieDG.getTag(), DW_TAG_null);
556 EXPECT_TRUE(!NullDieDG.getSibling().isValid());
557 EXPECT_TRUE(!NullDieDG.getFirstChild().isValid());
558 }
559
560 // Verify the previous sibling of our subprogram is our integer base type.
561 IntDieDG = NullDieDG.getPreviousSibling();
562 EXPECT_TRUE(IntDieDG.isValid());
563 EXPECT_EQ(IntDieDG.getTag(), DW_TAG_base_type);
564 }
565
566 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4Children) {
567 // Test that we can decode all forms for DWARF32, version 2, with 4 byte
568 // addresses.
569 typedef uint32_t AddrType;
570 TestChildren<2, AddrType>();
571 }
572
573 #ifdef _AIX
574 TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version2Addr8Children) {
575 #else
576 TEST(DWARFDebugInfo, TestDWARF32Version2Addr8Children) {
577 #endif
578 // Test that we can decode all forms for DWARF32, version 2, with 8 byte
579 // addresses.
580 typedef uint64_t AddrType;
581 TestChildren<2, AddrType>();
582 }
583
584 TEST(DWARFDebugInfo, TestDWARF32Version3Addr4Children) {
585 // Test that we can decode all forms for DWARF32, version 3, with 4 byte
586 // addresses.
587 typedef uint32_t AddrType;
588 TestChildren<3, AddrType>();
589 }
590
591 #ifdef _AIX
592 TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version3Addr8Children) {
593 #else
594 TEST(DWARFDebugInfo, TestDWARF32Version3Addr8Children) {
595 #endif
596 // Test that we can decode all forms for DWARF32, version 3, with 8 byte
597 // addresses.
598 typedef uint64_t AddrType;
599 TestChildren<3, AddrType>();
600 }
601
602 TEST(DWARFDebugInfo, TestDWARF32Version4Addr4Children) {
603 // Test that we can decode all forms for DWARF32, version 4, with 4 byte
604 // addresses.
605 typedef uint32_t AddrType;
606 TestChildren<4, AddrType>();
607 }
608
609 #ifdef _AIX
610 TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version4Addr8Children) {
611 #else
612 TEST(DWARFDebugInfo, TestDWARF32Version4Addr8Children) {
613 #endif
614 // Test that we can decode all forms for DWARF32, version 4, with 8 byte
615 // addresses.
616 typedef uint64_t AddrType;
617 TestChildren<4, AddrType>();
618 }
619
620 template <uint16_t Version, class AddrType> void TestReferences() {
621 Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
622 if (!isConfigurationSupported(Triple))
623 GTEST_SKIP();
624
625 // Test that we can decode DW_FORM_refXXX values correctly in DWARF.
626 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
627 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
628 dwarfgen::Generator *DG = ExpectedDG.get().get();
629 dwarfgen::CompileUnit &CU1 = DG->addCompileUnit();
630 dwarfgen::CompileUnit &CU2 = DG->addCompileUnit();
631
632 dwarfgen::DIE CU1Die = CU1.getUnitDIE();
633 CU1Die.addAttribute(DW_AT_name, DW_FORM_strp, "/tmp/main.c");
634 CU1Die.addAttribute(DW_AT_language, DW_FORM_data2, DW_LANG_C);
635
636 dwarfgen::DIE CU1TypeDie = CU1Die.addChild(DW_TAG_base_type);
637 CU1TypeDie.addAttribute(DW_AT_name, DW_FORM_strp, "int");
638 CU1TypeDie.addAttribute(DW_AT_encoding, DW_FORM_data1, DW_ATE_signed);
639 CU1TypeDie.addAttribute(DW_AT_byte_size, DW_FORM_data1, 4);
640
641 dwarfgen::DIE CU1Ref1Die = CU1Die.addChild(DW_TAG_variable);
642 CU1Ref1Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU1Ref1");
643 CU1Ref1Die.addAttribute(DW_AT_type, DW_FORM_ref1, CU1TypeDie);
644
645 dwarfgen::DIE CU1Ref2Die = CU1Die.addChild(DW_TAG_variable);
646 CU1Ref2Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU1Ref2");
647 CU1Ref2Die.addAttribute(DW_AT_type, DW_FORM_ref2, CU1TypeDie);
648
649 dwarfgen::DIE CU1Ref4Die = CU1Die.addChild(DW_TAG_variable);
650 CU1Ref4Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU1Ref4");
651 CU1Ref4Die.addAttribute(DW_AT_type, DW_FORM_ref4, CU1TypeDie);
652
653 dwarfgen::DIE CU1Ref8Die = CU1Die.addChild(DW_TAG_variable);
654 CU1Ref8Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU1Ref8");
655 CU1Ref8Die.addAttribute(DW_AT_type, DW_FORM_ref8, CU1TypeDie);
656
657 dwarfgen::DIE CU1RefAddrDie = CU1Die.addChild(DW_TAG_variable);
658 CU1RefAddrDie.addAttribute(DW_AT_name, DW_FORM_strp, "CU1RefAddr");
659 CU1RefAddrDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, CU1TypeDie);
660
661 dwarfgen::DIE CU2Die = CU2.getUnitDIE();
662 CU2Die.addAttribute(DW_AT_name, DW_FORM_strp, "/tmp/foo.c");
663 CU2Die.addAttribute(DW_AT_language, DW_FORM_data2, DW_LANG_C);
664
665 dwarfgen::DIE CU2TypeDie = CU2Die.addChild(DW_TAG_base_type);
666 CU2TypeDie.addAttribute(DW_AT_name, DW_FORM_strp, "float");
667 CU2TypeDie.addAttribute(DW_AT_encoding, DW_FORM_data1, DW_ATE_float);
668 CU2TypeDie.addAttribute(DW_AT_byte_size, DW_FORM_data1, 4);
669
670 dwarfgen::DIE CU2Ref1Die = CU2Die.addChild(DW_TAG_variable);
671 CU2Ref1Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU2Ref1");
672 CU2Ref1Die.addAttribute(DW_AT_type, DW_FORM_ref1, CU2TypeDie);
673
674 dwarfgen::DIE CU2Ref2Die = CU2Die.addChild(DW_TAG_variable);
675 CU2Ref2Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU2Ref2");
676 CU2Ref2Die.addAttribute(DW_AT_type, DW_FORM_ref2, CU2TypeDie);
677
678 dwarfgen::DIE CU2Ref4Die = CU2Die.addChild(DW_TAG_variable);
679 CU2Ref4Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU2Ref4");
680 CU2Ref4Die.addAttribute(DW_AT_type, DW_FORM_ref4, CU2TypeDie);
681
682 dwarfgen::DIE CU2Ref8Die = CU2Die.addChild(DW_TAG_variable);
683 CU2Ref8Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU2Ref8");
684 CU2Ref8Die.addAttribute(DW_AT_type, DW_FORM_ref8, CU2TypeDie);
685
686 dwarfgen::DIE CU2RefAddrDie = CU2Die.addChild(DW_TAG_variable);
687 CU2RefAddrDie.addAttribute(DW_AT_name, DW_FORM_strp, "CU2RefAddr");
688 CU2RefAddrDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, CU2TypeDie);
689
690 // Refer to a type in CU1 from CU2
691 dwarfgen::DIE CU2ToCU1RefAddrDie = CU2Die.addChild(DW_TAG_variable);
692 CU2ToCU1RefAddrDie.addAttribute(DW_AT_name, DW_FORM_strp, "CU2ToCU1RefAddr");
693 CU2ToCU1RefAddrDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, CU1TypeDie);
694
695 // Refer to a type in CU2 from CU1
696 dwarfgen::DIE CU1ToCU2RefAddrDie = CU1Die.addChild(DW_TAG_variable);
697 CU1ToCU2RefAddrDie.addAttribute(DW_AT_name, DW_FORM_strp, "CU1ToCU2RefAddr");
698 CU1ToCU2RefAddrDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, CU2TypeDie);
699
700 StringRef FileBytes = DG->generate();
701 MemoryBufferRef FileBuffer(FileBytes, "dwarf");
702 auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
703 EXPECT_TRUE((bool)Obj);
704 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
705
706 // Verify the number of compile units is correct.
707 uint32_t NumCUs = DwarfContext->getNumCompileUnits();
708 EXPECT_EQ(NumCUs, 2u);
709 DWARFCompileUnit *U1 =
710 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0));
711 DWARFCompileUnit *U2 =
712 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(1));
713
714 // Get the compile unit DIE is valid.
715 auto Unit1DieDG = U1->getUnitDIE(false);
716 EXPECT_TRUE(Unit1DieDG.isValid());
717
718 auto Unit2DieDG = U2->getUnitDIE(false);
719 EXPECT_TRUE(Unit2DieDG.isValid());
720
721 // Verify the first child of the compile unit 1 DIE is our int base type.
722 auto CU1TypeDieDG = Unit1DieDG.getFirstChild();
723 EXPECT_TRUE(CU1TypeDieDG.isValid());
724 EXPECT_EQ(CU1TypeDieDG.getTag(), DW_TAG_base_type);
725 EXPECT_EQ(DW_ATE_signed, toUnsigned(CU1TypeDieDG.find(DW_AT_encoding), 0));
726
727 // Verify the first child of the compile unit 2 DIE is our float base type.
728 auto CU2TypeDieDG = Unit2DieDG.getFirstChild();
729 EXPECT_TRUE(CU2TypeDieDG.isValid());
730 EXPECT_EQ(CU2TypeDieDG.getTag(), DW_TAG_base_type);
731 EXPECT_EQ(DW_ATE_float, toUnsigned(CU2TypeDieDG.find(DW_AT_encoding), 0));
732
733 // Verify the sibling of the base type DIE is our Ref1 DIE and that its
734 // DW_AT_type points to our base type DIE.
735 auto CU1Ref1DieDG = CU1TypeDieDG.getSibling();
736 EXPECT_TRUE(CU1Ref1DieDG.isValid());
737 EXPECT_EQ(CU1Ref1DieDG.getTag(), DW_TAG_variable);
738 EXPECT_EQ(CU1TypeDieDG.getOffset(),
739 toReference(CU1Ref1DieDG.find(DW_AT_type), -1ULL));
740 // Verify the sibling is our Ref2 DIE and that its DW_AT_type points to our
741 // base type DIE in CU1.
742 auto CU1Ref2DieDG = CU1Ref1DieDG.getSibling();
743 EXPECT_TRUE(CU1Ref2DieDG.isValid());
744 EXPECT_EQ(CU1Ref2DieDG.getTag(), DW_TAG_variable);
745 EXPECT_EQ(CU1TypeDieDG.getOffset(),
746 toReference(CU1Ref2DieDG.find(DW_AT_type), -1ULL));
747
748 // Verify the sibling is our Ref4 DIE and that its DW_AT_type points to our
749 // base type DIE in CU1.
750 auto CU1Ref4DieDG = CU1Ref2DieDG.getSibling();
751 EXPECT_TRUE(CU1Ref4DieDG.isValid());
752 EXPECT_EQ(CU1Ref4DieDG.getTag(), DW_TAG_variable);
753 EXPECT_EQ(CU1TypeDieDG.getOffset(),
754 toReference(CU1Ref4DieDG.find(DW_AT_type), -1ULL));
755
756 // Verify the sibling is our Ref8 DIE and that its DW_AT_type points to our
757 // base type DIE in CU1.
758 auto CU1Ref8DieDG = CU1Ref4DieDG.getSibling();
759 EXPECT_TRUE(CU1Ref8DieDG.isValid());
760 EXPECT_EQ(CU1Ref8DieDG.getTag(), DW_TAG_variable);
761 EXPECT_EQ(CU1TypeDieDG.getOffset(),
762 toReference(CU1Ref8DieDG.find(DW_AT_type), -1ULL));
763
764 // Verify the sibling is our RefAddr DIE and that its DW_AT_type points to our
765 // base type DIE in CU1.
766 auto CU1RefAddrDieDG = CU1Ref8DieDG.getSibling();
767 EXPECT_TRUE(CU1RefAddrDieDG.isValid());
768 EXPECT_EQ(CU1RefAddrDieDG.getTag(), DW_TAG_variable);
769 EXPECT_EQ(CU1TypeDieDG.getOffset(),
770 toReference(CU1RefAddrDieDG.find(DW_AT_type), -1ULL));
771
772 // Verify the sibling of the Ref4 DIE is our RefAddr DIE and that its
773 // DW_AT_type points to our base type DIE.
774 auto CU1ToCU2RefAddrDieDG = CU1RefAddrDieDG.getSibling();
775 EXPECT_TRUE(CU1ToCU2RefAddrDieDG.isValid());
776 EXPECT_EQ(CU1ToCU2RefAddrDieDG.getTag(), DW_TAG_variable);
777 EXPECT_EQ(CU2TypeDieDG.getOffset(),
778 toReference(CU1ToCU2RefAddrDieDG.find(DW_AT_type), -1ULL));
779
780 // Verify the sibling of the base type DIE is our Ref1 DIE and that its
781 // DW_AT_type points to our base type DIE.
782 auto CU2Ref1DieDG = CU2TypeDieDG.getSibling();
783 EXPECT_TRUE(CU2Ref1DieDG.isValid());
784 EXPECT_EQ(CU2Ref1DieDG.getTag(), DW_TAG_variable);
785 EXPECT_EQ(CU2TypeDieDG.getOffset(),
786 toReference(CU2Ref1DieDG.find(DW_AT_type), -1ULL));
787 // Verify the sibling is our Ref2 DIE and that its DW_AT_type points to our
788 // base type DIE in CU2.
789 auto CU2Ref2DieDG = CU2Ref1DieDG.getSibling();
790 EXPECT_TRUE(CU2Ref2DieDG.isValid());
791 EXPECT_EQ(CU2Ref2DieDG.getTag(), DW_TAG_variable);
792 EXPECT_EQ(CU2TypeDieDG.getOffset(),
793 toReference(CU2Ref2DieDG.find(DW_AT_type), -1ULL));
794
795 // Verify the sibling is our Ref4 DIE and that its DW_AT_type points to our
796 // base type DIE in CU2.
797 auto CU2Ref4DieDG = CU2Ref2DieDG.getSibling();
798 EXPECT_TRUE(CU2Ref4DieDG.isValid());
799 EXPECT_EQ(CU2Ref4DieDG.getTag(), DW_TAG_variable);
800 EXPECT_EQ(CU2TypeDieDG.getOffset(),
801 toReference(CU2Ref4DieDG.find(DW_AT_type), -1ULL));
802
803 // Verify the sibling is our Ref8 DIE and that its DW_AT_type points to our
804 // base type DIE in CU2.
805 auto CU2Ref8DieDG = CU2Ref4DieDG.getSibling();
806 EXPECT_TRUE(CU2Ref8DieDG.isValid());
807 EXPECT_EQ(CU2Ref8DieDG.getTag(), DW_TAG_variable);
808 EXPECT_EQ(CU2TypeDieDG.getOffset(),
809 toReference(CU2Ref8DieDG.find(DW_AT_type), -1ULL));
810
811 // Verify the sibling is our RefAddr DIE and that its DW_AT_type points to our
812 // base type DIE in CU2.
813 auto CU2RefAddrDieDG = CU2Ref8DieDG.getSibling();
814 EXPECT_TRUE(CU2RefAddrDieDG.isValid());
815 EXPECT_EQ(CU2RefAddrDieDG.getTag(), DW_TAG_variable);
816 EXPECT_EQ(CU2TypeDieDG.getOffset(),
817 toReference(CU2RefAddrDieDG.find(DW_AT_type), -1ULL));
818
819 // Verify the sibling of the Ref4 DIE is our RefAddr DIE and that its
820 // DW_AT_type points to our base type DIE.
821 auto CU2ToCU1RefAddrDieDG = CU2RefAddrDieDG.getSibling();
822 EXPECT_TRUE(CU2ToCU1RefAddrDieDG.isValid());
823 EXPECT_EQ(CU2ToCU1RefAddrDieDG.getTag(), DW_TAG_variable);
824 EXPECT_EQ(CU1TypeDieDG.getOffset(),
825 toReference(CU2ToCU1RefAddrDieDG.find(DW_AT_type), -1ULL));
826 }
827
828 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4References) {
829 // Test that we can decode all forms for DWARF32, version 2, with 4 byte
830 // addresses.
831 typedef uint32_t AddrType;
832 TestReferences<2, AddrType>();
833 }
834
835 #ifdef _AIX
836 TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version2Addr8References) {
837 #else
838 TEST(DWARFDebugInfo, TestDWARF32Version2Addr8References) {
839 #endif
840 // Test that we can decode all forms for DWARF32, version 2, with 8 byte
841 // addresses.
842 typedef uint64_t AddrType;
843 TestReferences<2, AddrType>();
844 }
845
846 TEST(DWARFDebugInfo, TestDWARF32Version3Addr4References) {
847 // Test that we can decode all forms for DWARF32, version 3, with 4 byte
848 // addresses.
849 typedef uint32_t AddrType;
850 TestReferences<3, AddrType>();
851 }
852
853 #ifdef _AIX
854 TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version3Addr8References) {
855 #else
856 TEST(DWARFDebugInfo, TestDWARF32Version3Addr8References) {
857 #endif
858 // Test that we can decode all forms for DWARF32, version 3, with 8 byte
859 // addresses.
860 typedef uint64_t AddrType;
861 TestReferences<3, AddrType>();
862 }
863
864 TEST(DWARFDebugInfo, TestDWARF32Version4Addr4References) {
865 // Test that we can decode all forms for DWARF32, version 4, with 4 byte
866 // addresses.
867 typedef uint32_t AddrType;
868 TestReferences<4, AddrType>();
869 }
870
871 #ifdef _AIX
872 TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version4Addr8References) {
873 #else
874 TEST(DWARFDebugInfo, TestDWARF32Version4Addr8References) {
875 #endif
876 // Test that we can decode all forms for DWARF32, version 4, with 8 byte
877 // addresses.
878 typedef uint64_t AddrType;
879 TestReferences<4, AddrType>();
880 }
881
882 template <uint16_t Version, class AddrType> void TestAddresses() {
883 Triple Triple = getDefaultTargetTripleForAddrSize(sizeof(AddrType));
884 if (!isConfigurationSupported(Triple))
885 GTEST_SKIP();
886
887 // Test the DWARF APIs related to accessing the DW_AT_low_pc and
888 // DW_AT_high_pc.
889 const bool SupportsHighPCAsOffset = Version >= 4;
890 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
891 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
892 dwarfgen::Generator *DG = ExpectedDG.get().get();
893 dwarfgen::CompileUnit &CU = DG->addCompileUnit();
894 dwarfgen::DIE CUDie = CU.getUnitDIE();
895
896 CUDie.addAttribute(DW_AT_name, DW_FORM_strp, "/tmp/main.c");
897 CUDie.addAttribute(DW_AT_language, DW_FORM_data2, DW_LANG_C);
898
899 // Create a subprogram DIE with no low or high PC.
900 dwarfgen::DIE SubprogramNoPC = CUDie.addChild(DW_TAG_subprogram);
901 SubprogramNoPC.addAttribute(DW_AT_name, DW_FORM_strp, "no_pc");
902
903 // Create a subprogram DIE with a low PC only.
904 dwarfgen::DIE SubprogramLowPC = CUDie.addChild(DW_TAG_subprogram);
905 SubprogramLowPC.addAttribute(DW_AT_name, DW_FORM_strp, "low_pc");
906 const uint64_t ActualLowPC = 0x1000;
907 const uint64_t ActualHighPC = 0x2000;
908 const uint64_t ActualHighPCOffset = ActualHighPC - ActualLowPC;
909 SubprogramLowPC.addAttribute(DW_AT_low_pc, DW_FORM_addr, ActualLowPC);
910
911 // Create a subprogram DIE with a low and high PC.
912 dwarfgen::DIE SubprogramLowHighPC = CUDie.addChild(DW_TAG_subprogram);
913 SubprogramLowHighPC.addAttribute(DW_AT_name, DW_FORM_strp, "low_high_pc");
914 SubprogramLowHighPC.addAttribute(DW_AT_low_pc, DW_FORM_addr, ActualLowPC);
915 // Encode the high PC as an offset from the low PC if supported.
916 if (SupportsHighPCAsOffset)
917 SubprogramLowHighPC.addAttribute(DW_AT_high_pc, DW_FORM_data4,
918 ActualHighPCOffset);
919 else
920 SubprogramLowHighPC.addAttribute(DW_AT_high_pc, DW_FORM_addr, ActualHighPC);
921
922 StringRef FileBytes = DG->generate();
923 MemoryBufferRef FileBuffer(FileBytes, "dwarf");
924 auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
925 EXPECT_TRUE((bool)Obj);
926 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
927
928 // Verify the number of compile units is correct.
929 uint32_t NumCUs = DwarfContext->getNumCompileUnits();
930 EXPECT_EQ(NumCUs, 1u);
931 DWARFCompileUnit *U =
932 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0));
933
934 // Get the compile unit DIE is valid.
935 auto DieDG = U->getUnitDIE(false);
936 EXPECT_TRUE(DieDG.isValid());
937
938 uint64_t LowPC, HighPC, SectionIndex;
939 std::optional<uint64_t> OptU64;
940 // Verify the that our subprogram with no PC value fails appropriately when
941 // asked for any PC values.
942 auto SubprogramDieNoPC = DieDG.getFirstChild();
943 EXPECT_TRUE(SubprogramDieNoPC.isValid());
944 EXPECT_EQ(SubprogramDieNoPC.getTag(), DW_TAG_subprogram);
945 OptU64 = toAddress(SubprogramDieNoPC.find(DW_AT_low_pc));
946 EXPECT_FALSE((bool)OptU64);
947 OptU64 = toAddress(SubprogramDieNoPC.find(DW_AT_high_pc));
948 EXPECT_FALSE((bool)OptU64);
949 EXPECT_FALSE(SubprogramDieNoPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
950 OptU64 = toAddress(SubprogramDieNoPC.find(DW_AT_high_pc));
951 EXPECT_FALSE((bool)OptU64);
952 OptU64 = toUnsigned(SubprogramDieNoPC.find(DW_AT_high_pc));
953 EXPECT_FALSE((bool)OptU64);
954 OptU64 = SubprogramDieNoPC.getHighPC(ActualLowPC);
955 EXPECT_FALSE((bool)OptU64);
956 EXPECT_FALSE(SubprogramDieNoPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
957
958 // Verify the that our subprogram with only a low PC value succeeds when
959 // we ask for the Low PC, but fails appropriately when asked for the high PC
960 // or both low and high PC values.
961 auto SubprogramDieLowPC = SubprogramDieNoPC.getSibling();
962 EXPECT_TRUE(SubprogramDieLowPC.isValid());
963 EXPECT_EQ(SubprogramDieLowPC.getTag(), DW_TAG_subprogram);
964 OptU64 = toAddress(SubprogramDieLowPC.find(DW_AT_low_pc));
965 EXPECT_TRUE((bool)OptU64);
966 EXPECT_EQ(*OptU64, ActualLowPC);
967 OptU64 = toAddress(SubprogramDieLowPC.find(DW_AT_high_pc));
968 EXPECT_FALSE((bool)OptU64);
969 OptU64 = toUnsigned(SubprogramDieLowPC.find(DW_AT_high_pc));
970 EXPECT_FALSE((bool)OptU64);
971 OptU64 = SubprogramDieLowPC.getHighPC(ActualLowPC);
972 EXPECT_FALSE((bool)OptU64);
973 EXPECT_FALSE(SubprogramDieLowPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
974
975 // Verify the that our subprogram with only a low PC value succeeds when
976 // we ask for the Low PC, but fails appropriately when asked for the high PC
977 // or both low and high PC values.
978 auto SubprogramDieLowHighPC = SubprogramDieLowPC.getSibling();
979 EXPECT_TRUE(SubprogramDieLowHighPC.isValid());
980 EXPECT_EQ(SubprogramDieLowHighPC.getTag(), DW_TAG_subprogram);
981 OptU64 = toAddress(SubprogramDieLowHighPC.find(DW_AT_low_pc));
982 EXPECT_TRUE((bool)OptU64);
983 EXPECT_EQ(*OptU64, ActualLowPC);
984 // Get the high PC as an address. This should succeed if the high PC was
985 // encoded as an address and fail if the high PC was encoded as an offset.
986 OptU64 = toAddress(SubprogramDieLowHighPC.find(DW_AT_high_pc));
987 if (SupportsHighPCAsOffset) {
988 EXPECT_FALSE((bool)OptU64);
989 } else {
990 EXPECT_TRUE((bool)OptU64);
991 EXPECT_EQ(*OptU64, ActualHighPC);
992 }
993 // Get the high PC as an unsigned constant. This should succeed if the high PC
994 // was encoded as an offset and fail if the high PC was encoded as an address.
995 OptU64 = toUnsigned(SubprogramDieLowHighPC.find(DW_AT_high_pc));
996 if (SupportsHighPCAsOffset) {
997 EXPECT_TRUE((bool)OptU64);
998 EXPECT_EQ(*OptU64, ActualHighPCOffset);
999 } else {
1000 EXPECT_FALSE((bool)OptU64);
1001 }
1002
1003 OptU64 = SubprogramDieLowHighPC.getHighPC(ActualLowPC);
1004 EXPECT_TRUE((bool)OptU64);
1005 EXPECT_EQ(*OptU64, ActualHighPC);
1006
1007 EXPECT_TRUE(SubprogramDieLowHighPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
1008 EXPECT_EQ(LowPC, ActualLowPC);
1009 EXPECT_EQ(HighPC, ActualHighPC);
1010 }
1011
1012 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4Addresses) {
1013 // Test that we can decode address values in DWARF32, version 2, with 4 byte
1014 // addresses.
1015 typedef uint32_t AddrType;
1016 TestAddresses<2, AddrType>();
1017 }
1018
1019 #ifdef _AIX
1020 TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version2Addr8Addresses) {
1021 #else
1022 TEST(DWARFDebugInfo, TestDWARF32Version2Addr8Addresses) {
1023 #endif
1024 // Test that we can decode address values in DWARF32, version 2, with 8 byte
1025 // addresses.
1026 typedef uint64_t AddrType;
1027 TestAddresses<2, AddrType>();
1028 }
1029
1030 TEST(DWARFDebugInfo, TestDWARF32Version3Addr4Addresses) {
1031 // Test that we can decode address values in DWARF32, version 3, with 4 byte
1032 // addresses.
1033 typedef uint32_t AddrType;
1034 TestAddresses<3, AddrType>();
1035 }
1036
1037 #ifdef _AIX
1038 TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version3Addr8Addresses) {
1039 #else
1040 TEST(DWARFDebugInfo, TestDWARF32Version3Addr8Addresses) {
1041 #endif
1042 // Test that we can decode address values in DWARF32, version 3, with 8 byte
1043 // addresses.
1044 typedef uint64_t AddrType;
1045 TestAddresses<3, AddrType>();
1046 }
1047
1048 TEST(DWARFDebugInfo, TestDWARF32Version4Addr4Addresses) {
1049 // Test that we can decode address values in DWARF32, version 4, with 4 byte
1050 // addresses.
1051 typedef uint32_t AddrType;
1052 TestAddresses<4, AddrType>();
1053 }
1054
1055 #ifdef _AIX
1056 TEST(DWARFDebugInfo, DISABLED_TestDWARF32Version4Addr8Addresses) {
1057 #else
1058 TEST(DWARFDebugInfo, TestDWARF32Version4Addr8Addresses) {
1059 #endif
1060 // Test that we can decode address values in DWARF32, version 4, with 8 byte
1061 // addresses.
1062 typedef uint64_t AddrType;
1063 TestAddresses<4, AddrType>();
1064 }
1065
1066 #ifdef _AIX
1067 TEST(DWARFDebugInfo, DISABLED_TestStringOffsets) {
1068 #else
1069 TEST(DWARFDebugInfo, TestStringOffsets) {
1070 #endif
1071 Triple Triple = getNormalizedDefaultTargetTriple();
1072 if (!isConfigurationSupported(Triple))
1073 GTEST_SKIP();
1074
1075 const char *String1 = "Hello";
1076 const char *String2 = "World";
1077
1078 auto ExpectedDG = dwarfgen::Generator::create(Triple, 5);
1079 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
1080 dwarfgen::Generator *DG = ExpectedDG.get().get();
1081 dwarfgen::CompileUnit &CU = DG->addCompileUnit();
1082 dwarfgen::DIE CUDie = CU.getUnitDIE();
1083
1084 CUDie.addStrOffsetsBaseAttribute();
1085
1086 uint16_t Attr = DW_AT_lo_user;
1087
1088 // Create our strings. First we create a non-indexed reference to String1,
1089 // followed by an indexed String2. Finally, we add an indexed reference to
1090 // String1.
1091 const auto Attr1 = static_cast<dwarf::Attribute>(Attr++);
1092 CUDie.addAttribute(Attr1, DW_FORM_strp, String1);
1093
1094 const auto Attr2 = static_cast<dwarf::Attribute>(Attr++);
1095 CUDie.addAttribute(Attr2, DW_FORM_strx, String2);
1096
1097 const auto Attr3 = static_cast<dwarf::Attribute>(Attr++);
1098 CUDie.addAttribute(Attr3, DW_FORM_strx, String1);
1099
1100 // Generate the DWARF
1101 StringRef FileBytes = DG->generate();
1102 MemoryBufferRef FileBuffer(FileBytes, "dwarf");
1103 auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
1104 ASSERT_TRUE((bool)Obj);
1105 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1106 uint32_t NumCUs = DwarfContext->getNumCompileUnits();
1107 ASSERT_EQ(NumCUs, 1u);
1108 DWARFUnit *U = DwarfContext->getUnitAtIndex(0);
1109 auto DieDG = U->getUnitDIE(false);
1110 ASSERT_TRUE(DieDG.isValid());
1111 ASSERT_TRUE(U->isLittleEndian() == Triple.isLittleEndian());
1112
1113 // Now make sure the string offsets came out properly. Attr2 should have index
1114 // 0 (because it was the first indexed string) even though the string itself
1115 // was added eariler.
1116 auto Extracted1 = toString(DieDG.find(Attr1));
1117 ASSERT_TRUE((bool)Extracted1);
1118 EXPECT_STREQ(String1, *Extracted1);
1119
1120 std::optional<DWARFFormValue> Form2 = DieDG.find(Attr2);
1121 ASSERT_TRUE((bool)Form2);
1122 EXPECT_EQ(0u, Form2->getRawUValue());
1123 auto Extracted2 = toString(Form2);
1124 ASSERT_TRUE((bool)Extracted2);
1125 EXPECT_STREQ(String2, *Extracted2);
1126
1127 std::optional<DWARFFormValue> Form3 = DieDG.find(Attr3);
1128 ASSERT_TRUE((bool)Form3);
1129 EXPECT_EQ(1u, Form3->getRawUValue());
1130 auto Extracted3 = toString(Form3);
1131 ASSERT_TRUE((bool)Extracted3);
1132 EXPECT_STREQ(String1, *Extracted3);
1133 }
1134
1135 #if defined(_AIX) && defined(__64BIT__)
1136 TEST(DWARFDebugInfo, DISABLED_TestEmptyStringOffsets) {
1137 #else
1138 TEST(DWARFDebugInfo, TestEmptyStringOffsets) {
1139 #endif
1140 Triple Triple = getNormalizedDefaultTargetTriple();
1141 if (!isConfigurationSupported(Triple))
1142 GTEST_SKIP();
1143
1144 const char *String1 = "Hello";
1145
1146 auto ExpectedDG = dwarfgen::Generator::create(Triple, 5);
1147 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
1148 dwarfgen::Generator *DG = ExpectedDG.get().get();
1149 dwarfgen::CompileUnit &CU = DG->addCompileUnit();
1150 dwarfgen::DIE CUDie = CU.getUnitDIE();
1151
1152 uint16_t Attr = DW_AT_lo_user;
1153
1154 // We shall insert only one string. It will be referenced directly.
1155 const auto Attr1 = static_cast<dwarf::Attribute>(Attr++);
1156 CUDie.addAttribute(Attr1, DW_FORM_strp, String1);
1157
1158 // Generate the DWARF
1159 StringRef FileBytes = DG->generate();
1160 MemoryBufferRef FileBuffer(FileBytes, "dwarf");
1161 auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
1162 ASSERT_TRUE((bool)Obj);
1163 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1164 EXPECT_TRUE(
1165 DwarfContext->getDWARFObj().getStrOffsetsSection().Data.empty());
1166 }
1167
1168 #if defined(_AIX) && defined(__64BIT__)
1169 TEST(DWARFDebugInfo, DISABLED_TestRelations) {
1170 #else
1171 TEST(DWARFDebugInfo, TestRelations) {
1172 #endif
1173 Triple Triple = getNormalizedDefaultTargetTriple();
1174 if (!isConfigurationSupported(Triple))
1175 GTEST_SKIP();
1176
1177 // Test the DWARF APIs related to accessing the DW_AT_low_pc and
1178 // DW_AT_high_pc.
1179 uint16_t Version = 4;
1180 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
1181 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
1182 dwarfgen::Generator *DG = ExpectedDG.get().get();
1183 dwarfgen::CompileUnit &CU = DG->addCompileUnit();
1184
1185 enum class Tag: uint16_t {
1186 A = dwarf::DW_TAG_lo_user,
1187 B,
1188 C,
1189 C1,
1190 C2,
1191 D,
1192 D1
1193 };
1194
1195 // Scope to allow us to re-use the same DIE names
1196 {
1197 // Create DWARF tree that looks like:
1198 //
1199 // CU
1200 // A
1201 // B
1202 // C
1203 // C1
1204 // C2
1205 // D
1206 // D1
1207 dwarfgen::DIE CUDie = CU.getUnitDIE();
1208 dwarfgen::DIE A = CUDie.addChild((dwarf::Tag)Tag::A);
1209 A.addChild((dwarf::Tag)Tag::B);
1210 dwarfgen::DIE C = A.addChild((dwarf::Tag)Tag::C);
1211 dwarfgen::DIE D = A.addChild((dwarf::Tag)Tag::D);
1212 C.addChild((dwarf::Tag)Tag::C1);
1213 C.addChild((dwarf::Tag)Tag::C2);
1214 D.addChild((dwarf::Tag)Tag::D1);
1215 }
1216
1217 MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
1218 auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
1219 EXPECT_TRUE((bool)Obj);
1220 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1221
1222 // Verify the number of compile units is correct.
1223 uint32_t NumCUs = DwarfContext->getNumCompileUnits();
1224 EXPECT_EQ(NumCUs, 1u);
1225 DWARFCompileUnit *U =
1226 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0));
1227
1228 // Get the compile unit DIE is valid.
1229 auto CUDie = U->getUnitDIE(false);
1230 EXPECT_TRUE(CUDie.isValid());
1231
1232 // The compile unit doesn't have a parent or a sibling.
1233 auto ParentDie = CUDie.getParent();
1234 EXPECT_FALSE(ParentDie.isValid());
1235 auto SiblingDie = CUDie.getSibling();
1236 EXPECT_FALSE(SiblingDie.isValid());
1237
1238 // Get the children of the compile unit
1239 auto A = CUDie.getFirstChild();
1240 auto B = A.getFirstChild();
1241 auto C = B.getSibling();
1242 auto D = C.getSibling();
1243 auto Null = D.getSibling();
1244
1245 // Verify NULL Die is NULL and has no children or siblings
1246 EXPECT_TRUE(Null.isNULL());
1247 EXPECT_FALSE(Null.getSibling().isValid());
1248 EXPECT_FALSE(Null.getFirstChild().isValid());
1249
1250 // Verify all children of the compile unit DIE are correct.
1251 EXPECT_EQ(A.getTag(), (dwarf::Tag)Tag::A);
1252 EXPECT_EQ(B.getTag(), (dwarf::Tag)Tag::B);
1253 EXPECT_EQ(C.getTag(), (dwarf::Tag)Tag::C);
1254 EXPECT_EQ(D.getTag(), (dwarf::Tag)Tag::D);
1255
1256 // Verify who has children
1257 EXPECT_TRUE(A.hasChildren());
1258 EXPECT_FALSE(B.hasChildren());
1259 EXPECT_TRUE(C.hasChildren());
1260 EXPECT_TRUE(D.hasChildren());
1261
1262 // Make sure the parent of all the children of the compile unit are the
1263 // compile unit.
1264 EXPECT_EQ(A.getParent(), CUDie);
1265
1266 // Make sure the parent of all the children of A are the A.
1267 // B is the first child in A, so we need to verify we can get the previous
1268 // DIE as the parent.
1269 EXPECT_EQ(B.getParent(), A);
1270 // C is the second child in A, so we need to make sure we can backup across
1271 // other DIE (B) at the same level to get the correct parent.
1272 EXPECT_EQ(C.getParent(), A);
1273 // D is the third child of A. We need to verify we can backup across other DIE
1274 // (B and C) including DIE that have children (D) to get the correct parent.
1275 EXPECT_EQ(D.getParent(), A);
1276
1277 // Verify that a DIE with no children returns an invalid DWARFDie.
1278 EXPECT_FALSE(B.getFirstChild().isValid());
1279
1280 // Verify the children of the B DIE
1281 auto C1 = C.getFirstChild();
1282 auto C2 = C1.getSibling();
1283 EXPECT_TRUE(C2.getSibling().isNULL());
1284
1285 // Verify all children of the B DIE correctly valid or invalid.
1286 EXPECT_EQ(C1.getTag(), (dwarf::Tag)Tag::C1);
1287 EXPECT_EQ(C2.getTag(), (dwarf::Tag)Tag::C2);
1288
1289 // Make sure the parent of all the children of the B are the B.
1290 EXPECT_EQ(C1.getParent(), C);
1291 EXPECT_EQ(C2.getParent(), C);
1292
1293 // Make sure iterators work as expected.
1294 EXPECT_THAT(std::vector<DWARFDie>(A.begin(), A.end()),
1295 testing::ElementsAre(B, C, D));
1296 EXPECT_THAT(std::vector<DWARFDie>(A.rbegin(), A.rend()),
1297 testing::ElementsAre(D, C, B));
1298
1299 // Make sure conversion from reverse iterator works as expected.
1300 EXPECT_EQ(A.rbegin().base(), A.end());
1301 EXPECT_EQ(A.rend().base(), A.begin());
1302
1303 // Make sure iterator is bidirectional.
1304 {
1305 auto Begin = A.begin();
1306 auto End = A.end();
1307 auto It = A.begin();
1308
1309 EXPECT_EQ(It, Begin);
1310 EXPECT_EQ(*It, B);
1311 ++It;
1312 EXPECT_EQ(*It, C);
1313 ++It;
1314 EXPECT_EQ(*It, D);
1315 ++It;
1316 EXPECT_EQ(It, End);
1317 --It;
1318 EXPECT_EQ(*It, D);
1319 --It;
1320 EXPECT_EQ(*It, C);
1321 --It;
1322 EXPECT_EQ(*It, B);
1323 EXPECT_EQ(It, Begin);
1324 }
1325
1326 // Make sure reverse iterator is bidirectional.
1327 {
1328 auto Begin = A.rbegin();
1329 auto End = A.rend();
1330 auto It = A.rbegin();
1331
1332 EXPECT_EQ(It, Begin);
1333 EXPECT_EQ(*It, D);
1334 ++It;
1335 EXPECT_EQ(*It, C);
1336 ++It;
1337 EXPECT_EQ(*It, B);
1338 ++It;
1339 EXPECT_EQ(It, End);
1340 --It;
1341 EXPECT_EQ(*It, B);
1342 --It;
1343 EXPECT_EQ(*It, C);
1344 --It;
1345 EXPECT_EQ(*It, D);
1346 EXPECT_EQ(It, Begin);
1347 }
1348 }
1349
1350 TEST(DWARFDebugInfo, TestDWARFDie) {
1351 // Make sure a default constructed DWARFDie doesn't have any parent, sibling
1352 // or child;
1353 DWARFDie DefaultDie;
1354 EXPECT_FALSE(DefaultDie.getParent().isValid());
1355 EXPECT_FALSE(DefaultDie.getFirstChild().isValid());
1356 EXPECT_FALSE(DefaultDie.getSibling().isValid());
1357 }
1358
1359 #if defined(_AIX) && defined(__64BIT__)
1360 TEST(DWARFDebugInfo, DISABLED_TestChildIterators) {
1361 #else
1362 TEST(DWARFDebugInfo, TestChildIterators) {
1363 #endif
1364 Triple Triple = getNormalizedDefaultTargetTriple();
1365 if (!isConfigurationSupported(Triple))
1366 GTEST_SKIP();
1367
1368 // Test the DWARF APIs related to iterating across the children of a DIE using
1369 // the DWARFDie::iterator class.
1370 uint16_t Version = 4;
1371 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
1372 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
1373 dwarfgen::Generator *DG = ExpectedDG.get().get();
1374 dwarfgen::CompileUnit &CU = DG->addCompileUnit();
1375
1376 enum class Tag: uint16_t {
1377 A = dwarf::DW_TAG_lo_user,
1378 B,
1379 };
1380
1381 // Scope to allow us to re-use the same DIE names
1382 {
1383 // Create DWARF tree that looks like:
1384 //
1385 // CU
1386 // A
1387 // B
1388 auto CUDie = CU.getUnitDIE();
1389 CUDie.addChild((dwarf::Tag)Tag::A);
1390 CUDie.addChild((dwarf::Tag)Tag::B);
1391 }
1392
1393 MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
1394 auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
1395 EXPECT_TRUE((bool)Obj);
1396 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1397
1398 // Verify the number of compile units is correct.
1399 uint32_t NumCUs = DwarfContext->getNumCompileUnits();
1400 EXPECT_EQ(NumCUs, 1u);
1401 DWARFCompileUnit *U =
1402 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0));
1403
1404 // Get the compile unit DIE is valid.
1405 auto CUDie = U->getUnitDIE(false);
1406 EXPECT_TRUE(CUDie.isValid());
1407 uint32_t Index;
1408 DWARFDie A;
1409 DWARFDie B;
1410
1411 // Verify the compile unit DIE's children.
1412 Index = 0;
1413 for (auto Die : CUDie.children()) {
1414 switch (Index++) {
1415 case 0: A = Die; break;
1416 case 1: B = Die; break;
1417 }
1418 }
1419
1420 EXPECT_EQ(A.getTag(), (dwarf::Tag)Tag::A);
1421 EXPECT_EQ(B.getTag(), (dwarf::Tag)Tag::B);
1422
1423 // Verify that A has no children by verifying that the begin and end contain
1424 // invalid DIEs and also that the iterators are equal.
1425 EXPECT_EQ(A.begin(), A.end());
1426 }
1427
1428 TEST(DWARFDebugInfo, TestChildIteratorsOnInvalidDie) {
1429 // Verify that an invalid DIE has no children.
1430 DWARFDie Invalid;
1431 auto begin = Invalid.begin();
1432 auto end = Invalid.end();
1433 EXPECT_FALSE(begin->isValid());
1434 EXPECT_FALSE(end->isValid());
1435 EXPECT_EQ(begin, end);
1436 }
1437
1438 TEST(DWARFDebugInfo, TestEmptyChildren) {
1439 const char *yamldata = "debug_abbrev:\n"
1440 " - Table:\n"
1441 " - Code: 0x00000001\n"
1442 " Tag: DW_TAG_compile_unit\n"
1443 " Children: DW_CHILDREN_yes\n"
1444 "debug_info:\n"
1445 " - Version: 4\n"
1446 " AddrSize: 8\n"
1447 " Entries:\n"
1448 " - AbbrCode: 0x00000001\n"
1449 " - AbbrCode: 0x00000000\n";
1450
1451 auto ErrOrSections = DWARFYAML::emitDebugSections(StringRef(yamldata));
1452 ASSERT_TRUE((bool)ErrOrSections);
1453 std::unique_ptr<DWARFContext> DwarfContext =
1454 DWARFContext::create(*ErrOrSections, 8);
1455
1456 // Verify the number of compile units is correct.
1457 uint32_t NumCUs = DwarfContext->getNumCompileUnits();
1458 EXPECT_EQ(NumCUs, 1u);
1459 DWARFCompileUnit *U =
1460 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0));
1461
1462 // Get the compile unit DIE is valid.
1463 auto CUDie = U->getUnitDIE(false);
1464 EXPECT_TRUE(CUDie.isValid());
1465
1466 // Verify that the CU Die that says it has children, but doesn't, actually
1467 // has begin and end iterators that are equal. We want to make sure we don't
1468 // see the Null DIEs during iteration.
1469 EXPECT_EQ(CUDie.begin(), CUDie.end());
1470 }
1471
1472 #if defined(_AIX) && defined(__64BIT__)
1473 TEST(DWARFDebugInfo, DISABLED_TestAttributeIterators) {
1474 #else
1475 TEST(DWARFDebugInfo, TestAttributeIterators) {
1476 #endif
1477 Triple Triple = getNormalizedDefaultTargetTriple();
1478 if (!isConfigurationSupported(Triple))
1479 GTEST_SKIP();
1480
1481 // Test the DWARF APIs related to iterating across all attribute values in a
1482 // a DWARFDie.
1483 uint16_t Version = 4;
1484 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
1485 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
1486 dwarfgen::Generator *DG = ExpectedDG.get().get();
1487 dwarfgen::CompileUnit &CU = DG->addCompileUnit();
1488 const uint64_t CULowPC = 0x1000;
1489 StringRef CUPath("/tmp/main.c");
1490
1491 // Scope to allow us to re-use the same DIE names
1492 {
1493 auto CUDie = CU.getUnitDIE();
1494 // Encode an attribute value before an attribute with no data.
1495 CUDie.addAttribute(DW_AT_name, DW_FORM_strp, CUPath.data());
1496 // Encode an attribute value with no data in .debug_info/types to ensure
1497 // the iteration works correctly.
1498 CUDie.addAttribute(DW_AT_declaration, DW_FORM_flag_present);
1499 // Encode an attribute value after an attribute with no data.
1500 CUDie.addAttribute(DW_AT_low_pc, DW_FORM_addr, CULowPC);
1501 }
1502
1503 MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
1504 auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
1505 EXPECT_TRUE((bool)Obj);
1506 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1507
1508 // Verify the number of compile units is correct.
1509 uint32_t NumCUs = DwarfContext->getNumCompileUnits();
1510 EXPECT_EQ(NumCUs, 1u);
1511 DWARFCompileUnit *U =
1512 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0));
1513
1514 // Get the compile unit DIE is valid.
1515 auto CUDie = U->getUnitDIE(false);
1516 EXPECT_TRUE(CUDie.isValid());
1517
1518 auto R = CUDie.attributes();
1519 auto I = R.begin();
1520 auto E = R.end();
1521
1522 ASSERT_NE(E, I);
1523 EXPECT_EQ(I->Attr, DW_AT_name);
1524 auto ActualCUPath = toString(I->Value);
1525 EXPECT_EQ(CUPath, *ActualCUPath);
1526
1527 ASSERT_NE(E, ++I);
1528 EXPECT_EQ(I->Attr, DW_AT_declaration);
1529 EXPECT_EQ(1ull, *I->Value.getAsUnsignedConstant());
1530
1531 ASSERT_NE(E, ++I);
1532 EXPECT_EQ(I->Attr, DW_AT_low_pc);
1533 EXPECT_EQ(CULowPC, *I->Value.getAsAddress());
1534
1535 EXPECT_EQ(E, ++I);
1536 }
1537
1538 #if defined(_AIX) && defined(__64BIT__)
1539 TEST(DWARFDebugInfo, DISABLED_TestFindRecurse) {
1540 #else
1541 TEST(DWARFDebugInfo, TestFindRecurse) {
1542 #endif
1543 Triple Triple = getNormalizedDefaultTargetTriple();
1544 if (!isConfigurationSupported(Triple))
1545 GTEST_SKIP();
1546
1547 uint16_t Version = 4;
1548 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
1549 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
1550 dwarfgen::Generator *DG = ExpectedDG.get().get();
1551 dwarfgen::CompileUnit &CU = DG->addCompileUnit();
1552
1553 StringRef SpecDieName = "spec";
1554 StringRef SpecLinkageName = "spec_linkage";
1555 StringRef AbsDieName = "abs";
1556 // Scope to allow us to re-use the same DIE names
1557 {
1558 auto CUDie = CU.getUnitDIE();
1559 auto FuncSpecDie = CUDie.addChild(DW_TAG_subprogram);
1560 auto FuncAbsDie = CUDie.addChild(DW_TAG_subprogram);
1561 // Put the linkage name in a second abstract origin DIE to ensure we
1562 // recurse through more than just one DIE when looking for attributes.
1563 auto FuncAbsDie2 = CUDie.addChild(DW_TAG_subprogram);
1564 auto FuncDie = CUDie.addChild(DW_TAG_subprogram);
1565 auto VarAbsDie = CUDie.addChild(DW_TAG_variable);
1566 auto VarDie = CUDie.addChild(DW_TAG_variable);
1567 FuncSpecDie.addAttribute(DW_AT_name, DW_FORM_strp, SpecDieName);
1568 FuncAbsDie2.addAttribute(DW_AT_linkage_name, DW_FORM_strp, SpecLinkageName);
1569 FuncAbsDie.addAttribute(DW_AT_specification, DW_FORM_ref4, FuncSpecDie);
1570 FuncAbsDie.addAttribute(DW_AT_abstract_origin, DW_FORM_ref4, FuncAbsDie2);
1571 FuncDie.addAttribute(DW_AT_abstract_origin, DW_FORM_ref4, FuncAbsDie);
1572 VarAbsDie.addAttribute(DW_AT_name, DW_FORM_strp, AbsDieName);
1573 VarDie.addAttribute(DW_AT_abstract_origin, DW_FORM_ref4, VarAbsDie);
1574 }
1575
1576 MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
1577 auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
1578 EXPECT_TRUE((bool)Obj);
1579 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1580
1581 // Verify the number of compile units is correct.
1582 uint32_t NumCUs = DwarfContext->getNumCompileUnits();
1583 EXPECT_EQ(NumCUs, 1u);
1584 DWARFCompileUnit *U =
1585 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0));
1586
1587 // Get the compile unit DIE is valid.
1588 auto CUDie = U->getUnitDIE(false);
1589 EXPECT_TRUE(CUDie.isValid());
1590
1591 auto FuncSpecDie = CUDie.getFirstChild();
1592 auto FuncAbsDie = FuncSpecDie.getSibling();
1593 auto FuncAbsDie2 = FuncAbsDie.getSibling();
1594 auto FuncDie = FuncAbsDie2.getSibling();
1595 auto VarAbsDie = FuncDie.getSibling();
1596 auto VarDie = VarAbsDie.getSibling();
1597
1598 // Make sure we can't extract the name from the specification die when using
1599 // DWARFDie::find() since it won't check the DW_AT_specification DIE.
1600 EXPECT_FALSE(FuncDie.find(DW_AT_name));
1601
1602 // Make sure we can extract the name from the specification die when using
1603 // DWARFDie::findRecursively() since it should recurse through the
1604 // DW_AT_specification DIE.
1605 auto NameOpt = FuncDie.findRecursively(DW_AT_name);
1606 EXPECT_TRUE(NameOpt);
1607 // Test the dwarf::toString() helper function.
1608 auto StringOpt = toString(NameOpt);
1609 EXPECT_TRUE(StringOpt);
1610 EXPECT_EQ(SpecDieName, StringOpt.value_or(nullptr));
1611 // Test the dwarf::toString() helper function with a default value specified.
1612 EXPECT_EQ(SpecDieName, toString(NameOpt, nullptr));
1613
1614 auto LinkageNameOpt = FuncDie.findRecursively(DW_AT_linkage_name);
1615 EXPECT_EQ(SpecLinkageName, toString(LinkageNameOpt).value_or(nullptr));
1616
1617 // Make sure we can't extract the name from the abstract origin die when using
1618 // DWARFDie::find() since it won't check the DW_AT_abstract_origin DIE.
1619 EXPECT_FALSE(VarDie.find(DW_AT_name));
1620
1621 // Make sure we can extract the name from the abstract origin die when using
1622 // DWARFDie::findRecursively() since it should recurse through the
1623 // DW_AT_abstract_origin DIE.
1624 NameOpt = VarDie.findRecursively(DW_AT_name);
1625 EXPECT_TRUE(NameOpt);
1626 // Test the dwarf::toString() helper function.
1627 StringOpt = toString(NameOpt);
1628 EXPECT_TRUE(StringOpt);
1629 EXPECT_EQ(AbsDieName, StringOpt.value_or(nullptr));
1630 }
1631
1632 TEST(DWARFDebugInfo, TestDwarfToFunctions) {
1633 // Test all of the dwarf::toXXX functions that take a
1634 // std::optional<DWARFFormValue> and extract the values from it.
1635 uint64_t InvalidU64 = 0xBADBADBADBADBADB;
1636 int64_t InvalidS64 = 0xBADBADBADBADBADB;
1637
1638 // First test that we don't get valid values back when using an optional with
1639 // no value.
1640 std::optional<DWARFFormValue> FormValOpt1 = DWARFFormValue();
1641 EXPECT_FALSE(toString(FormValOpt1).has_value());
1642 EXPECT_FALSE(toUnsigned(FormValOpt1).has_value());
1643 EXPECT_FALSE(toReference(FormValOpt1).has_value());
1644 EXPECT_FALSE(toSigned(FormValOpt1).has_value());
1645 EXPECT_FALSE(toAddress(FormValOpt1).has_value());
1646 EXPECT_FALSE(toSectionOffset(FormValOpt1).has_value());
1647 EXPECT_FALSE(toBlock(FormValOpt1).has_value());
1648 EXPECT_EQ(nullptr, toString(FormValOpt1, nullptr));
1649 EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt1, InvalidU64));
1650 EXPECT_EQ(InvalidU64, toReference(FormValOpt1, InvalidU64));
1651 EXPECT_EQ(InvalidU64, toAddress(FormValOpt1, InvalidU64));
1652 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt1, InvalidU64));
1653 EXPECT_EQ(InvalidS64, toSigned(FormValOpt1, InvalidS64));
1654
1655 // Test successful and unsuccessful address decoding.
1656 uint64_t Address = 0x100000000ULL;
1657 std::optional<DWARFFormValue> FormValOpt2 =
1658 DWARFFormValue::createFromUValue(DW_FORM_addr, Address);
1659
1660 EXPECT_FALSE(toString(FormValOpt2).has_value());
1661 EXPECT_FALSE(toUnsigned(FormValOpt2).has_value());
1662 EXPECT_FALSE(toReference(FormValOpt2).has_value());
1663 EXPECT_FALSE(toSigned(FormValOpt2).has_value());
1664 EXPECT_TRUE(toAddress(FormValOpt2).has_value());
1665 EXPECT_FALSE(toSectionOffset(FormValOpt2).has_value());
1666 EXPECT_FALSE(toBlock(FormValOpt2).has_value());
1667 EXPECT_EQ(nullptr, toString(FormValOpt2, nullptr));
1668 EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt2, InvalidU64));
1669 EXPECT_EQ(InvalidU64, toReference(FormValOpt2, InvalidU64));
1670 EXPECT_EQ(Address, toAddress(FormValOpt2, InvalidU64));
1671 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt2, InvalidU64));
1672 EXPECT_EQ(InvalidS64, toSigned(FormValOpt2, InvalidU64));
1673
1674 // Test successful and unsuccessful unsigned constant decoding.
1675 uint64_t UData8 = 0x1020304050607080ULL;
1676 std::optional<DWARFFormValue> FormValOpt3 =
1677 DWARFFormValue::createFromUValue(DW_FORM_udata, UData8);
1678
1679 EXPECT_FALSE(toString(FormValOpt3).has_value());
1680 EXPECT_TRUE(toUnsigned(FormValOpt3).has_value());
1681 EXPECT_FALSE(toReference(FormValOpt3).has_value());
1682 EXPECT_TRUE(toSigned(FormValOpt3).has_value());
1683 EXPECT_FALSE(toAddress(FormValOpt3).has_value());
1684 EXPECT_FALSE(toSectionOffset(FormValOpt3).has_value());
1685 EXPECT_FALSE(toBlock(FormValOpt3).has_value());
1686 EXPECT_EQ(nullptr, toString(FormValOpt3, nullptr));
1687 EXPECT_EQ(UData8, toUnsigned(FormValOpt3, InvalidU64));
1688 EXPECT_EQ(InvalidU64, toReference(FormValOpt3, InvalidU64));
1689 EXPECT_EQ(InvalidU64, toAddress(FormValOpt3, InvalidU64));
1690 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt3, InvalidU64));
1691 EXPECT_EQ((int64_t)UData8, toSigned(FormValOpt3, InvalidU64));
1692
1693 // Test successful and unsuccessful reference decoding.
1694 uint32_t RefData = 0x11223344U;
1695 std::optional<DWARFFormValue> FormValOpt4 =
1696 DWARFFormValue::createFromUValue(DW_FORM_ref_addr, RefData);
1697
1698 EXPECT_FALSE(toString(FormValOpt4).has_value());
1699 EXPECT_FALSE(toUnsigned(FormValOpt4).has_value());
1700 EXPECT_TRUE(toReference(FormValOpt4).has_value());
1701 EXPECT_FALSE(toSigned(FormValOpt4).has_value());
1702 EXPECT_FALSE(toAddress(FormValOpt4).has_value());
1703 EXPECT_FALSE(toSectionOffset(FormValOpt4).has_value());
1704 EXPECT_FALSE(toBlock(FormValOpt4).has_value());
1705 EXPECT_EQ(nullptr, toString(FormValOpt4, nullptr));
1706 EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt4, InvalidU64));
1707 EXPECT_EQ(RefData, toReference(FormValOpt4, InvalidU64));
1708 EXPECT_EQ(InvalidU64, toAddress(FormValOpt4, InvalidU64));
1709 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt4, InvalidU64));
1710 EXPECT_EQ(InvalidS64, toSigned(FormValOpt4, InvalidU64));
1711
1712 // Test successful and unsuccessful signed constant decoding.
1713 int64_t SData8 = 0x1020304050607080ULL;
1714 std::optional<DWARFFormValue> FormValOpt5 =
1715 DWARFFormValue::createFromSValue(DW_FORM_udata, SData8);
1716
1717 EXPECT_FALSE(toString(FormValOpt5).has_value());
1718 EXPECT_TRUE(toUnsigned(FormValOpt5).has_value());
1719 EXPECT_FALSE(toReference(FormValOpt5).has_value());
1720 EXPECT_TRUE(toSigned(FormValOpt5).has_value());
1721 EXPECT_FALSE(toAddress(FormValOpt5).has_value());
1722 EXPECT_FALSE(toSectionOffset(FormValOpt5).has_value());
1723 EXPECT_FALSE(toBlock(FormValOpt5).has_value());
1724 EXPECT_EQ(nullptr, toString(FormValOpt5, nullptr));
1725 EXPECT_EQ((uint64_t)SData8, toUnsigned(FormValOpt5, InvalidU64));
1726 EXPECT_EQ(InvalidU64, toReference(FormValOpt5, InvalidU64));
1727 EXPECT_EQ(InvalidU64, toAddress(FormValOpt5, InvalidU64));
1728 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt5, InvalidU64));
1729 EXPECT_EQ(SData8, toSigned(FormValOpt5, InvalidU64));
1730
1731 // Test successful and unsuccessful block decoding.
1732 uint8_t Data[] = { 2, 3, 4 };
1733 ArrayRef<uint8_t> Array(Data);
1734 std::optional<DWARFFormValue> FormValOpt6 =
1735 DWARFFormValue::createFromBlockValue(DW_FORM_block1, Array);
1736
1737 EXPECT_FALSE(toString(FormValOpt6).has_value());
1738 EXPECT_FALSE(toUnsigned(FormValOpt6).has_value());
1739 EXPECT_FALSE(toReference(FormValOpt6).has_value());
1740 EXPECT_FALSE(toSigned(FormValOpt6).has_value());
1741 EXPECT_FALSE(toAddress(FormValOpt6).has_value());
1742 EXPECT_FALSE(toSectionOffset(FormValOpt6).has_value());
1743 auto BlockOpt = toBlock(FormValOpt6);
1744 EXPECT_TRUE(BlockOpt.has_value());
1745 EXPECT_EQ(*BlockOpt, Array);
1746 EXPECT_EQ(nullptr, toString(FormValOpt6, nullptr));
1747 EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt6, InvalidU64));
1748 EXPECT_EQ(InvalidU64, toReference(FormValOpt6, InvalidU64));
1749 EXPECT_EQ(InvalidU64, toAddress(FormValOpt6, InvalidU64));
1750 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt6, InvalidU64));
1751 EXPECT_EQ(InvalidS64, toSigned(FormValOpt6, InvalidU64));
1752
1753 // Test
1754 }
1755
1756 #if defined(_AIX) && defined(__64BIT__)
1757 TEST(DWARFDebugInfo, DISABLED_TestFindAttrs) {
1758 #else
1759 TEST(DWARFDebugInfo, TestFindAttrs) {
1760 #endif
1761 Triple Triple = getNormalizedDefaultTargetTriple();
1762 if (!isConfigurationSupported(Triple))
1763 GTEST_SKIP();
1764
1765 // Test the DWARFDie::find() and DWARFDie::findRecursively() that take an
1766 // ArrayRef<dwarf::Attribute> value to make sure they work correctly.
1767 uint16_t Version = 4;
1768 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
1769 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
1770 dwarfgen::Generator *DG = ExpectedDG.get().get();
1771 dwarfgen::CompileUnit &CU = DG->addCompileUnit();
1772
1773 StringRef DieMangled("_Z3fooi");
1774 // Scope to allow us to re-use the same DIE names
1775 {
1776 auto CUDie = CU.getUnitDIE();
1777 auto FuncSpecDie = CUDie.addChild(DW_TAG_subprogram);
1778 auto FuncDie = CUDie.addChild(DW_TAG_subprogram);
1779 FuncSpecDie.addAttribute(DW_AT_MIPS_linkage_name, DW_FORM_strp, DieMangled);
1780 FuncDie.addAttribute(DW_AT_specification, DW_FORM_ref4, FuncSpecDie);
1781 }
1782
1783 MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
1784 auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
1785 EXPECT_TRUE((bool)Obj);
1786 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1787
1788 // Verify the number of compile units is correct.
1789 uint32_t NumCUs = DwarfContext->getNumCompileUnits();
1790 EXPECT_EQ(NumCUs, 1u);
1791 DWARFCompileUnit *U =
1792 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0));
1793
1794 // Get the compile unit DIE is valid.
1795 auto CUDie = U->getUnitDIE(false);
1796 EXPECT_TRUE(CUDie.isValid());
1797
1798 auto FuncSpecDie = CUDie.getFirstChild();
1799 auto FuncDie = FuncSpecDie.getSibling();
1800
1801 // Make sure that passing in an empty attribute list behave correctly.
1802 EXPECT_FALSE(FuncDie.find(ArrayRef<dwarf::Attribute>()).has_value());
1803
1804 // Make sure that passing in a list of attribute that are not contained
1805 // in the DIE returns nothing.
1806 EXPECT_FALSE(FuncDie.find({DW_AT_low_pc, DW_AT_entry_pc}).has_value());
1807
1808 const dwarf::Attribute Attrs[] = {DW_AT_linkage_name,
1809 DW_AT_MIPS_linkage_name};
1810
1811 // Make sure we can't extract the linkage name attributes when using
1812 // DWARFDie::find() since it won't check the DW_AT_specification DIE.
1813 EXPECT_FALSE(FuncDie.find(Attrs).has_value());
1814
1815 // Make sure we can extract the name from the specification die when using
1816 // DWARFDie::findRecursively() since it should recurse through the
1817 // DW_AT_specification DIE.
1818 auto NameOpt = FuncDie.findRecursively(Attrs);
1819 EXPECT_TRUE(NameOpt.has_value());
1820 EXPECT_EQ(DieMangled, toString(NameOpt, ""));
1821 }
1822
1823 #if defined(_AIX) && defined(__64BIT__)
1824 TEST(DWARFDebugInfo, DISABLED_TestImplicitConstAbbrevs) {
1825 #else
1826 TEST(DWARFDebugInfo, TestImplicitConstAbbrevs) {
1827 #endif
1828 Triple Triple = getNormalizedDefaultTargetTriple();
1829 if (!isConfigurationSupported(Triple))
1830 GTEST_SKIP();
1831
1832 uint16_t Version = 5;
1833 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version);
1834 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded());
1835 dwarfgen::Generator *DG = ExpectedDG.get().get();
1836 dwarfgen::CompileUnit &CU = DG->addCompileUnit();
1837 dwarfgen::DIE CUDie = CU.getUnitDIE();
1838 const dwarf::Attribute Attr = DW_AT_lo_user;
1839 const int64_t Val1 = 42;
1840 const int64_t Val2 = 43;
1841
1842 auto FirstVal1DIE = CUDie.addChild(DW_TAG_class_type);
1843 FirstVal1DIE.addAttribute(Attr, DW_FORM_implicit_const, Val1);
1844
1845 auto SecondVal1DIE = CUDie.addChild(DW_TAG_class_type);
1846 SecondVal1DIE.addAttribute(Attr, DW_FORM_implicit_const, Val1);
1847
1848 auto Val2DIE = CUDie.addChild(DW_TAG_class_type);
1849 Val2DIE.addAttribute(Attr, DW_FORM_implicit_const, Val2);
1850
1851 MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
1852 auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
1853 EXPECT_TRUE((bool)Obj);
1854 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj);
1855 DWARFCompileUnit *U =
1856 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0));
1857 EXPECT_TRUE((bool)U);
1858
1859 const auto *Abbrevs = U->getAbbreviations();
1860 EXPECT_TRUE((bool)Abbrevs);
1861
1862 // Let's find implicit_const abbrevs and verify,
1863 // that there are exactly two of them and both of them
1864 // can be dumped correctly.
1865 typedef decltype(Abbrevs->begin()) AbbrevIt;
1866 AbbrevIt Val1Abbrev = Abbrevs->end();
1867 AbbrevIt Val2Abbrev = Abbrevs->end();
1868 for(auto it = Abbrevs->begin(); it != Abbrevs->end(); ++it) {
1869 if (it->getNumAttributes() == 0)
1870 continue; // root abbrev for DW_TAG_compile_unit
1871
1872 auto A = it->getAttrByIndex(0);
1873 EXPECT_EQ(A, Attr);
1874
1875 std::optional<uint32_t> AttrIndex = it->findAttributeIndex(A);
1876 EXPECT_TRUE((bool)AttrIndex);
1877 EXPECT_EQ(*AttrIndex, 0u);
1878 uint64_t OffsetVal =
1879 it->getAttributeOffsetFromIndex(*AttrIndex, /* offset */ 0, *U);
1880 EXPECT_TRUE(it->getAttributeValueFromOffset(*AttrIndex, OffsetVal, *U));
1881
1882 auto FormValue = it->getAttributeValue(/* offset */ 0, A, *U);
1883 EXPECT_TRUE((bool)FormValue);
1884 EXPECT_EQ(FormValue->getForm(), dwarf::DW_FORM_implicit_const);
1885
1886 const auto V = FormValue->getAsSignedConstant();
1887 EXPECT_TRUE((bool)V);
1888
1889 auto VerifyAbbrevDump = [&V](AbbrevIt it) {
1890 std::string S;
1891 llvm::raw_string_ostream OS(S);
1892 it->dump(OS);
1893 auto FormPos = OS.str().find("DW_FORM_implicit_const");
1894 EXPECT_NE(FormPos, std::string::npos);
1895 auto ValPos = S.find_first_of("-0123456789", FormPos);
1896 EXPECT_NE(ValPos, std::string::npos);
1897 int64_t Val = std::atoll(S.substr(ValPos).c_str());
1898 EXPECT_EQ(Val, *V);
1899 };
1900
1901 switch(*V) {
1902 case Val1:
1903 EXPECT_EQ(Val1Abbrev, Abbrevs->end());
1904 Val1Abbrev = it;
1905 VerifyAbbrevDump(it);
1906 break;
1907 case Val2:
1908 EXPECT_EQ(Val2Abbrev, Abbrevs->end());
1909 Val2Abbrev = it;
1910 VerifyAbbrevDump(it);
1911 break;
1912 default:
1913 FAIL() << "Unexpected attribute value: " << *V;
1914 }
1915 }
1916
1917 // Now let's make sure that two Val1-DIEs refer to the same abbrev,
1918 // and Val2-DIE refers to another one.
1919 auto DieDG = U->getUnitDIE(false);
1920 auto it = DieDG.begin();
1921 std::multimap<int64_t, decltype(it->getAbbreviationDeclarationPtr())> DIEs;
1922 const DWARFAbbreviationDeclaration *AbbrevPtrVal1 = nullptr;
1923 const DWARFAbbreviationDeclaration *AbbrevPtrVal2 = nullptr;
1924 for (; it != DieDG.end(); ++it) {
1925 const auto *AbbrevPtr = it->getAbbreviationDeclarationPtr();
1926 EXPECT_TRUE((bool)AbbrevPtr);
1927 auto FormValue = it->find(Attr);
1928 EXPECT_TRUE((bool)FormValue);
1929 const auto V = FormValue->getAsSignedConstant();
1930 EXPECT_TRUE((bool)V);
1931 switch(*V) {
1932 case Val1:
1933 AbbrevPtrVal1 = AbbrevPtr;
1934 break;
1935 case Val2:
1936 AbbrevPtrVal2 = AbbrevPtr;
1937 break;
1938 default:
1939 FAIL() << "Unexpected attribute value: " << *V;
1940 }
1941 DIEs.insert(std::make_pair(*V, AbbrevPtr));
1942 }
1943 EXPECT_EQ(DIEs.count(Val1), 2u);
1944 EXPECT_EQ(DIEs.count(Val2), 1u);
1945 auto Val1Range = DIEs.equal_range(Val1);
1946 for (auto it = Val1Range.first; it != Val1Range.second; ++it)
1947 EXPECT_EQ(it->second, AbbrevPtrVal1);
1948 EXPECT_EQ(DIEs.find(Val2)->second, AbbrevPtrVal2);
1949 }
1950
1951 TEST(DWARFDebugInfo, TestDWARFDieRangeInfoContains) {
1952 DWARFVerifier::DieRangeInfo Empty;
1953 ASSERT_TRUE(Empty.contains(Empty));
1954
1955 DWARFVerifier::DieRangeInfo Ranges(
1956 {{0x10, 0x20}, {0x30, 0x40}, {0x40, 0x50}});
1957
1958 ASSERT_TRUE(Ranges.contains(Empty));
1959 ASSERT_FALSE(Ranges.contains({{{0x0f, 0x10}}}));
1960 ASSERT_FALSE(Ranges.contains({{{0x0f, 0x20}}}));
1961 ASSERT_FALSE(Ranges.contains({{{0x0f, 0x21}}}));
1962
1963 // Test ranges that start at R's start address
1964 ASSERT_TRUE(Ranges.contains({{{0x10, 0x10}}}));
1965 ASSERT_TRUE(Ranges.contains({{{0x10, 0x11}}}));
1966 ASSERT_TRUE(Ranges.contains({{{0x10, 0x20}}}));
1967 ASSERT_FALSE(Ranges.contains({{{0x10, 0x21}}}));
1968
1969 ASSERT_TRUE(Ranges.contains({{{0x11, 0x12}}}));
1970
1971 // Test ranges that start at last bytes of Range
1972 ASSERT_TRUE(Ranges.contains({{{0x1f, 0x20}}}));
1973 ASSERT_FALSE(Ranges.contains({{{0x1f, 0x21}}}));
1974
1975 // Test ranges that start after Range
1976 ASSERT_TRUE(Ranges.contains({{{0x20, 0x20}}}));
1977 ASSERT_FALSE(Ranges.contains({{{0x20, 0x21}}}));
1978
1979 ASSERT_TRUE(Ranges.contains({{{0x31, 0x32}}}));
1980 ASSERT_TRUE(Ranges.contains({{{0x3f, 0x40}}}));
1981 ASSERT_TRUE(Ranges.contains({{{0x10, 0x20}, {0x30, 0x40}}}));
1982 ASSERT_TRUE(Ranges.contains({{{0x11, 0x12}, {0x31, 0x32}}}));
1983 ASSERT_TRUE(Ranges.contains(
1984 {{{0x11, 0x12}, {0x12, 0x13}, {0x31, 0x32}, {0x32, 0x33}}}));
1985 ASSERT_FALSE(Ranges.contains({{{0x11, 0x12},
1986 {0x12, 0x13},
1987 {0x20, 0x21},
1988 {0x31, 0x32},
1989 {0x32, 0x33}}}));
1990 ASSERT_FALSE(Ranges.contains(
1991 {{{0x11, 0x12}, {0x12, 0x13}, {0x31, 0x32}, {0x32, 0x51}}}));
1992 ASSERT_TRUE(Ranges.contains({{{0x11, 0x12}, {0x30, 0x50}}}));
1993 ASSERT_FALSE(Ranges.contains({{{0x30, 0x51}}}));
1994 ASSERT_FALSE(Ranges.contains({{{0x50, 0x51}}}));
1995 }
1996
1997 namespace {
1998
1999 void AssertRangesIntersect(const DWARFAddressRange &LHS,
2000 const DWARFAddressRange &RHS) {
2001 ASSERT_TRUE(LHS.intersects(RHS));
2002 ASSERT_TRUE(RHS.intersects(LHS));
2003 }
2004 void AssertRangesDontIntersect(const DWARFAddressRange &LHS,
2005 const DWARFAddressRange &RHS) {
2006 ASSERT_FALSE(LHS.intersects(RHS));
2007 ASSERT_FALSE(RHS.intersects(LHS));
2008 }
2009
2010 void AssertRangesIntersect(const DWARFVerifier::DieRangeInfo &LHS,
2011 const DWARFAddressRangesVector &Ranges) {
2012 DWARFVerifier::DieRangeInfo RHS(Ranges);
2013 ASSERT_TRUE(LHS.intersects(RHS));
2014 ASSERT_TRUE(RHS.intersects(LHS));
2015 }
2016
2017 void AssertRangesDontIntersect(const DWARFVerifier::DieRangeInfo &LHS,
2018 const DWARFAddressRangesVector &Ranges) {
2019 DWARFVerifier::DieRangeInfo RHS(Ranges);
2020 ASSERT_FALSE(LHS.intersects(RHS));
2021 ASSERT_FALSE(RHS.intersects(LHS));
2022 }
2023
2024 } // namespace
2025 TEST(DWARFDebugInfo, TestDwarfRangesIntersect) {
2026 DWARFAddressRange R(0x10, 0x20);
2027
2028 //----------------------------------------------------------------------
2029 // Test ranges that start before R...
2030 //----------------------------------------------------------------------
2031 // Other range ends before start of R
2032 AssertRangesDontIntersect(R, {0x00, 0x10});
2033 // Other range end address is start of a R
2034 AssertRangesIntersect(R, {0x00, 0x11});
2035 // Other range end address is in R
2036 AssertRangesIntersect(R, {0x00, 0x15});
2037 // Other range end address is at and of R
2038 AssertRangesIntersect(R, {0x00, 0x20});
2039 // Other range end address is past end of R
2040 AssertRangesIntersect(R, {0x00, 0x40});
2041
2042 //----------------------------------------------------------------------
2043 // Test ranges that start at R's start address
2044 //----------------------------------------------------------------------
2045 // Ensure empty ranges doesn't match
2046 AssertRangesDontIntersect(R, {0x10, 0x10});
2047 // 1 byte of Range
2048 AssertRangesIntersect(R, {0x10, 0x11});
2049 // same as Range
2050 AssertRangesIntersect(R, {0x10, 0x20});
2051 // 1 byte past Range
2052 AssertRangesIntersect(R, {0x10, 0x21});
2053
2054 //----------------------------------------------------------------------
2055 // Test ranges that start inside Range
2056 //----------------------------------------------------------------------
2057 // empty in range
2058 AssertRangesDontIntersect(R, {0x11, 0x11});
2059 // all in Range
2060 AssertRangesIntersect(R, {0x11, 0x1f});
2061 // ends at end of Range
2062 AssertRangesIntersect(R, {0x11, 0x20});
2063 // ends past Range
2064 AssertRangesIntersect(R, {0x11, 0x21});
2065
2066 //----------------------------------------------------------------------
2067 // Test ranges that start at last bytes of Range
2068 //----------------------------------------------------------------------
2069 // ends at end of Range
2070 AssertRangesIntersect(R, {0x1f, 0x20});
2071 // ends past Range
2072 AssertRangesIntersect(R, {0x1f, 0x21});
2073
2074 //----------------------------------------------------------------------
2075 // Test ranges that start after Range
2076 //----------------------------------------------------------------------
2077 // empty just past in Range
2078 AssertRangesDontIntersect(R, {0x20, 0x20});
2079 // valid past Range
2080 AssertRangesDontIntersect(R, {0x20, 0x21});
2081 }
2082
2083 TEST(DWARFDebugInfo, TestDWARFDieRangeInfoIntersects) {
2084
2085 DWARFVerifier::DieRangeInfo Ranges({{0x10, 0x20}, {0x30, 0x40}});
2086
2087 // Test empty range
2088 AssertRangesDontIntersect(Ranges, {});
2089 // Test range that appears before all ranges in Ranges
2090 AssertRangesDontIntersect(Ranges, {{0x00, 0x10}});
2091 // Test range that appears between ranges in Ranges
2092 AssertRangesDontIntersect(Ranges, {{0x20, 0x30}});
2093 // Test range that appears after ranges in Ranges
2094 AssertRangesDontIntersect(Ranges, {{0x40, 0x50}});
2095
2096 // Test range that start before first range
2097 AssertRangesIntersect(Ranges, {{0x00, 0x11}});
2098 // Test range that start at first range
2099 AssertRangesIntersect(Ranges, {{0x10, 0x11}});
2100 // Test range that start in first range
2101 AssertRangesIntersect(Ranges, {{0x11, 0x12}});
2102 // Test range that start at end of first range
2103 AssertRangesIntersect(Ranges, {{0x1f, 0x20}});
2104 // Test range that starts at end of first range
2105 AssertRangesDontIntersect(Ranges, {{0x20, 0x21}});
2106 // Test range that starts at end of first range
2107 AssertRangesIntersect(Ranges, {{0x20, 0x31}});
2108
2109 // Test range that start before second range and ends before second
2110 AssertRangesDontIntersect(Ranges, {{0x2f, 0x30}});
2111 // Test range that start before second range and ends in second
2112 AssertRangesIntersect(Ranges, {{0x2f, 0x31}});
2113 // Test range that start at second range
2114 AssertRangesIntersect(Ranges, {{0x30, 0x31}});
2115 // Test range that start in second range
2116 AssertRangesIntersect(Ranges, {{0x31, 0x32}});
2117 // Test range that start at end of second range
2118 AssertRangesIntersect(Ranges, {{0x3f, 0x40}});
2119 // Test range that starts at end of second range
2120 AssertRangesDontIntersect(Ranges, {{0x40, 0x41}});
2121
2122 AssertRangesDontIntersect(Ranges, {{0x20, 0x21}, {0x2f, 0x30}});
2123 AssertRangesIntersect(Ranges, {{0x20, 0x21}, {0x2f, 0x31}});
2124 }
2125
2126 TEST(DWARFDebugInfo, TestDWARF64UnitLength) {
2127 static const char DebugInfoSecRaw[] =
2128 "\xff\xff\xff\xff" // DWARF64 mark
2129 "\x88\x77\x66\x55\x44\x33\x22\x11" // Length
2130 "\x05\x00" // Version
2131 "\x01" // DW_UT_compile
2132 "\x04" // Address size
2133 "\0\0\0\0\0\0\0\0"; // Offset Into Abbrev. Sec.
2134 StringMap<std::unique_ptr<MemoryBuffer>> Sections;
2135 Sections.insert(std::make_pair(
2136 "debug_info", MemoryBuffer::getMemBuffer(StringRef(
2137 DebugInfoSecRaw, sizeof(DebugInfoSecRaw) - 1))));
2138 auto Context = DWARFContext::create(Sections, /* AddrSize = */ 4,
2139 /* isLittleEndian = */ true);
2140 const auto &Obj = Context->getDWARFObj();
2141 Obj.forEachInfoSections([&](const DWARFSection &Sec) {
2142 DWARFUnitHeader Header;
2143 DWARFDataExtractor Data(Obj, Sec, /* IsLittleEndian = */ true,
2144 /* AddressSize = */ 4);
2145 uint64_t Offset = 0;
2146 EXPECT_FALSE(Header.extract(*Context, Data, &Offset, DW_SECT_INFO));
2147 // Header.extract() returns false because there is not enough space
2148 // in the section for the declared length. Anyway, we can check that
2149 // the properties are read correctly.
2150 ASSERT_EQ(DwarfFormat::DWARF64, Header.getFormat());
2151 ASSERT_EQ(0x1122334455667788ULL, Header.getLength());
2152 ASSERT_EQ(5, Header.getVersion());
2153 ASSERT_EQ(DW_UT_compile, Header.getUnitType());
2154 ASSERT_EQ(4, Header.getAddressByteSize());
2155
2156 // Check that the length can be correctly read in the unit class.
2157 DWARFUnitVector DummyUnitVector;
2158 DWARFSection DummySec;
2159 DWARFCompileUnit CU(*Context, Sec, Header, /* DA = */ 0, /* RS = */ 0,
2160 /* LocSection = */ 0, /* SS = */ StringRef(),
2161 /* SOS = */ DummySec, /* AOS = */ 0,
2162 /* LS = */ DummySec, /* LE = */ true,
2163 /* isDWO= */ false, DummyUnitVector);
2164 ASSERT_EQ(0x1122334455667788ULL, CU.getLength());
2165 });
2166 }
2167
2168 } // end anonymous namespace