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