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 (!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 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 #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 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.getValue(), 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.getValue(), 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.getValue(), 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.getValue(), ActualHighPCOffset); 999 } else { 1000 EXPECT_FALSE((bool)OptU64); 1001 } 1002 1003 OptU64 = SubprogramDieLowHighPC.getHighPC(ActualLowPC); 1004 EXPECT_TRUE((bool)OptU64); 1005 EXPECT_EQ(OptU64.getValue(), 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 1112 // Now make sure the string offsets came out properly. Attr2 should have index 1113 // 0 (because it was the first indexed string) even though the string itself 1114 // was added eariler. 1115 auto Extracted1 = toString(DieDG.find(Attr1)); 1116 ASSERT_TRUE((bool)Extracted1); 1117 EXPECT_STREQ(String1, *Extracted1); 1118 1119 Optional<DWARFFormValue> Form2 = DieDG.find(Attr2); 1120 ASSERT_TRUE((bool)Form2); 1121 EXPECT_EQ(0u, Form2->getRawUValue()); 1122 auto Extracted2 = toString(Form2); 1123 ASSERT_TRUE((bool)Extracted2); 1124 EXPECT_STREQ(String2, *Extracted2); 1125 1126 Optional<DWARFFormValue> Form3 = DieDG.find(Attr3); 1127 ASSERT_TRUE((bool)Form3); 1128 EXPECT_EQ(1u, Form3->getRawUValue()); 1129 auto Extracted3 = toString(Form3); 1130 ASSERT_TRUE((bool)Extracted3); 1131 EXPECT_STREQ(String1, *Extracted3); 1132 } 1133 1134 #if defined(_AIX) && defined(__64BIT__) 1135 TEST(DWARFDebugInfo, DISABLED_TestEmptyStringOffsets) { 1136 #else 1137 TEST(DWARFDebugInfo, TestEmptyStringOffsets) { 1138 #endif 1139 Triple Triple = getNormalizedDefaultTargetTriple(); 1140 if (!isConfigurationSupported(Triple)) 1141 GTEST_SKIP(); 1142 1143 const char *String1 = "Hello"; 1144 1145 auto ExpectedDG = dwarfgen::Generator::create(Triple, 5); 1146 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded()); 1147 dwarfgen::Generator *DG = ExpectedDG.get().get(); 1148 dwarfgen::CompileUnit &CU = DG->addCompileUnit(); 1149 dwarfgen::DIE CUDie = CU.getUnitDIE(); 1150 1151 uint16_t Attr = DW_AT_lo_user; 1152 1153 // We shall insert only one string. It will be referenced directly. 1154 const auto Attr1 = static_cast<dwarf::Attribute>(Attr++); 1155 CUDie.addAttribute(Attr1, DW_FORM_strp, String1); 1156 1157 // Generate the DWARF 1158 StringRef FileBytes = DG->generate(); 1159 MemoryBufferRef FileBuffer(FileBytes, "dwarf"); 1160 auto Obj = object::ObjectFile::createObjectFile(FileBuffer); 1161 ASSERT_TRUE((bool)Obj); 1162 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj); 1163 EXPECT_TRUE( 1164 DwarfContext->getDWARFObj().getStrOffsetsSection().Data.empty()); 1165 } 1166 1167 #if defined(_AIX) && defined(__64BIT__) 1168 TEST(DWARFDebugInfo, DISABLED_TestRelations) { 1169 #else 1170 TEST(DWARFDebugInfo, TestRelations) { 1171 #endif 1172 Triple Triple = getNormalizedDefaultTargetTriple(); 1173 if (!isConfigurationSupported(Triple)) 1174 GTEST_SKIP(); 1175 1176 // Test the DWARF APIs related to accessing the DW_AT_low_pc and 1177 // DW_AT_high_pc. 1178 uint16_t Version = 4; 1179 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version); 1180 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded()); 1181 dwarfgen::Generator *DG = ExpectedDG.get().get(); 1182 dwarfgen::CompileUnit &CU = DG->addCompileUnit(); 1183 1184 enum class Tag: uint16_t { 1185 A = dwarf::DW_TAG_lo_user, 1186 B, 1187 C, 1188 C1, 1189 C2, 1190 D, 1191 D1 1192 }; 1193 1194 // Scope to allow us to re-use the same DIE names 1195 { 1196 // Create DWARF tree that looks like: 1197 // 1198 // CU 1199 // A 1200 // B 1201 // C 1202 // C1 1203 // C2 1204 // D 1205 // D1 1206 dwarfgen::DIE CUDie = CU.getUnitDIE(); 1207 dwarfgen::DIE A = CUDie.addChild((dwarf::Tag)Tag::A); 1208 A.addChild((dwarf::Tag)Tag::B); 1209 dwarfgen::DIE C = A.addChild((dwarf::Tag)Tag::C); 1210 dwarfgen::DIE D = A.addChild((dwarf::Tag)Tag::D); 1211 C.addChild((dwarf::Tag)Tag::C1); 1212 C.addChild((dwarf::Tag)Tag::C2); 1213 D.addChild((dwarf::Tag)Tag::D1); 1214 } 1215 1216 MemoryBufferRef FileBuffer(DG->generate(), "dwarf"); 1217 auto Obj = object::ObjectFile::createObjectFile(FileBuffer); 1218 EXPECT_TRUE((bool)Obj); 1219 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj); 1220 1221 // Verify the number of compile units is correct. 1222 uint32_t NumCUs = DwarfContext->getNumCompileUnits(); 1223 EXPECT_EQ(NumCUs, 1u); 1224 DWARFCompileUnit *U = 1225 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0)); 1226 1227 // Get the compile unit DIE is valid. 1228 auto CUDie = U->getUnitDIE(false); 1229 EXPECT_TRUE(CUDie.isValid()); 1230 1231 // The compile unit doesn't have a parent or a sibling. 1232 auto ParentDie = CUDie.getParent(); 1233 EXPECT_FALSE(ParentDie.isValid()); 1234 auto SiblingDie = CUDie.getSibling(); 1235 EXPECT_FALSE(SiblingDie.isValid()); 1236 1237 // Get the children of the compile unit 1238 auto A = CUDie.getFirstChild(); 1239 auto B = A.getFirstChild(); 1240 auto C = B.getSibling(); 1241 auto D = C.getSibling(); 1242 auto Null = D.getSibling(); 1243 1244 // Verify NULL Die is NULL and has no children or siblings 1245 EXPECT_TRUE(Null.isNULL()); 1246 EXPECT_FALSE(Null.getSibling().isValid()); 1247 EXPECT_FALSE(Null.getFirstChild().isValid()); 1248 1249 // Verify all children of the compile unit DIE are correct. 1250 EXPECT_EQ(A.getTag(), (dwarf::Tag)Tag::A); 1251 EXPECT_EQ(B.getTag(), (dwarf::Tag)Tag::B); 1252 EXPECT_EQ(C.getTag(), (dwarf::Tag)Tag::C); 1253 EXPECT_EQ(D.getTag(), (dwarf::Tag)Tag::D); 1254 1255 // Verify who has children 1256 EXPECT_TRUE(A.hasChildren()); 1257 EXPECT_FALSE(B.hasChildren()); 1258 EXPECT_TRUE(C.hasChildren()); 1259 EXPECT_TRUE(D.hasChildren()); 1260 1261 // Make sure the parent of all the children of the compile unit are the 1262 // compile unit. 1263 EXPECT_EQ(A.getParent(), CUDie); 1264 1265 // Make sure the parent of all the children of A are the A. 1266 // B is the first child in A, so we need to verify we can get the previous 1267 // DIE as the parent. 1268 EXPECT_EQ(B.getParent(), A); 1269 // C is the second child in A, so we need to make sure we can backup across 1270 // other DIE (B) at the same level to get the correct parent. 1271 EXPECT_EQ(C.getParent(), A); 1272 // D is the third child of A. We need to verify we can backup across other DIE 1273 // (B and C) including DIE that have children (D) to get the correct parent. 1274 EXPECT_EQ(D.getParent(), A); 1275 1276 // Verify that a DIE with no children returns an invalid DWARFDie. 1277 EXPECT_FALSE(B.getFirstChild().isValid()); 1278 1279 // Verify the children of the B DIE 1280 auto C1 = C.getFirstChild(); 1281 auto C2 = C1.getSibling(); 1282 EXPECT_TRUE(C2.getSibling().isNULL()); 1283 1284 // Verify all children of the B DIE correctly valid or invalid. 1285 EXPECT_EQ(C1.getTag(), (dwarf::Tag)Tag::C1); 1286 EXPECT_EQ(C2.getTag(), (dwarf::Tag)Tag::C2); 1287 1288 // Make sure the parent of all the children of the B are the B. 1289 EXPECT_EQ(C1.getParent(), C); 1290 EXPECT_EQ(C2.getParent(), C); 1291 1292 // Make sure iterators work as expected. 1293 EXPECT_THAT(std::vector<DWARFDie>(A.begin(), A.end()), 1294 testing::ElementsAre(B, C, D)); 1295 EXPECT_THAT(std::vector<DWARFDie>(A.rbegin(), A.rend()), 1296 testing::ElementsAre(D, C, B)); 1297 1298 // Make sure conversion from reverse iterator works as expected. 1299 EXPECT_EQ(A.rbegin().base(), A.end()); 1300 EXPECT_EQ(A.rend().base(), A.begin()); 1301 1302 // Make sure iterator is bidirectional. 1303 { 1304 auto Begin = A.begin(); 1305 auto End = A.end(); 1306 auto It = A.begin(); 1307 1308 EXPECT_EQ(It, Begin); 1309 EXPECT_EQ(*It, B); 1310 ++It; 1311 EXPECT_EQ(*It, C); 1312 ++It; 1313 EXPECT_EQ(*It, D); 1314 ++It; 1315 EXPECT_EQ(It, End); 1316 --It; 1317 EXPECT_EQ(*It, D); 1318 --It; 1319 EXPECT_EQ(*It, C); 1320 --It; 1321 EXPECT_EQ(*It, B); 1322 EXPECT_EQ(It, Begin); 1323 } 1324 1325 // Make sure reverse iterator is bidirectional. 1326 { 1327 auto Begin = A.rbegin(); 1328 auto End = A.rend(); 1329 auto It = A.rbegin(); 1330 1331 EXPECT_EQ(It, Begin); 1332 EXPECT_EQ(*It, D); 1333 ++It; 1334 EXPECT_EQ(*It, C); 1335 ++It; 1336 EXPECT_EQ(*It, B); 1337 ++It; 1338 EXPECT_EQ(It, End); 1339 --It; 1340 EXPECT_EQ(*It, B); 1341 --It; 1342 EXPECT_EQ(*It, C); 1343 --It; 1344 EXPECT_EQ(*It, D); 1345 EXPECT_EQ(It, Begin); 1346 } 1347 } 1348 1349 TEST(DWARFDebugInfo, TestDWARFDie) { 1350 // Make sure a default constructed DWARFDie doesn't have any parent, sibling 1351 // or child; 1352 DWARFDie DefaultDie; 1353 EXPECT_FALSE(DefaultDie.getParent().isValid()); 1354 EXPECT_FALSE(DefaultDie.getFirstChild().isValid()); 1355 EXPECT_FALSE(DefaultDie.getSibling().isValid()); 1356 } 1357 1358 #if defined(_AIX) && defined(__64BIT__) 1359 TEST(DWARFDebugInfo, DISABLED_TestChildIterators) { 1360 #else 1361 TEST(DWARFDebugInfo, TestChildIterators) { 1362 #endif 1363 Triple Triple = getNormalizedDefaultTargetTriple(); 1364 if (!isConfigurationSupported(Triple)) 1365 GTEST_SKIP(); 1366 1367 // Test the DWARF APIs related to iterating across the children of a DIE using 1368 // the DWARFDie::iterator class. 1369 uint16_t Version = 4; 1370 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version); 1371 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded()); 1372 dwarfgen::Generator *DG = ExpectedDG.get().get(); 1373 dwarfgen::CompileUnit &CU = DG->addCompileUnit(); 1374 1375 enum class Tag: uint16_t { 1376 A = dwarf::DW_TAG_lo_user, 1377 B, 1378 }; 1379 1380 // Scope to allow us to re-use the same DIE names 1381 { 1382 // Create DWARF tree that looks like: 1383 // 1384 // CU 1385 // A 1386 // B 1387 auto CUDie = CU.getUnitDIE(); 1388 CUDie.addChild((dwarf::Tag)Tag::A); 1389 CUDie.addChild((dwarf::Tag)Tag::B); 1390 } 1391 1392 MemoryBufferRef FileBuffer(DG->generate(), "dwarf"); 1393 auto Obj = object::ObjectFile::createObjectFile(FileBuffer); 1394 EXPECT_TRUE((bool)Obj); 1395 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj); 1396 1397 // Verify the number of compile units is correct. 1398 uint32_t NumCUs = DwarfContext->getNumCompileUnits(); 1399 EXPECT_EQ(NumCUs, 1u); 1400 DWARFCompileUnit *U = 1401 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0)); 1402 1403 // Get the compile unit DIE is valid. 1404 auto CUDie = U->getUnitDIE(false); 1405 EXPECT_TRUE(CUDie.isValid()); 1406 uint32_t Index; 1407 DWARFDie A; 1408 DWARFDie B; 1409 1410 // Verify the compile unit DIE's children. 1411 Index = 0; 1412 for (auto Die : CUDie.children()) { 1413 switch (Index++) { 1414 case 0: A = Die; break; 1415 case 1: B = Die; break; 1416 } 1417 } 1418 1419 EXPECT_EQ(A.getTag(), (dwarf::Tag)Tag::A); 1420 EXPECT_EQ(B.getTag(), (dwarf::Tag)Tag::B); 1421 1422 // Verify that A has no children by verifying that the begin and end contain 1423 // invalid DIEs and also that the iterators are equal. 1424 EXPECT_EQ(A.begin(), A.end()); 1425 } 1426 1427 TEST(DWARFDebugInfo, TestChildIteratorsOnInvalidDie) { 1428 // Verify that an invalid DIE has no children. 1429 DWARFDie Invalid; 1430 auto begin = Invalid.begin(); 1431 auto end = Invalid.end(); 1432 EXPECT_FALSE(begin->isValid()); 1433 EXPECT_FALSE(end->isValid()); 1434 EXPECT_EQ(begin, end); 1435 } 1436 1437 TEST(DWARFDebugInfo, TestEmptyChildren) { 1438 const char *yamldata = "debug_abbrev:\n" 1439 " - Table:\n" 1440 " - Code: 0x00000001\n" 1441 " Tag: DW_TAG_compile_unit\n" 1442 " Children: DW_CHILDREN_yes\n" 1443 "debug_info:\n" 1444 " - Version: 4\n" 1445 " AddrSize: 8\n" 1446 " Entries:\n" 1447 " - AbbrCode: 0x00000001\n" 1448 " - AbbrCode: 0x00000000\n"; 1449 1450 auto ErrOrSections = DWARFYAML::emitDebugSections(StringRef(yamldata)); 1451 ASSERT_TRUE((bool)ErrOrSections); 1452 std::unique_ptr<DWARFContext> DwarfContext = 1453 DWARFContext::create(*ErrOrSections, 8); 1454 1455 // Verify the number of compile units is correct. 1456 uint32_t NumCUs = DwarfContext->getNumCompileUnits(); 1457 EXPECT_EQ(NumCUs, 1u); 1458 DWARFCompileUnit *U = 1459 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0)); 1460 1461 // Get the compile unit DIE is valid. 1462 auto CUDie = U->getUnitDIE(false); 1463 EXPECT_TRUE(CUDie.isValid()); 1464 1465 // Verify that the CU Die that says it has children, but doesn't, actually 1466 // has begin and end iterators that are equal. We want to make sure we don't 1467 // see the Null DIEs during iteration. 1468 EXPECT_EQ(CUDie.begin(), CUDie.end()); 1469 } 1470 1471 #if defined(_AIX) && defined(__64BIT__) 1472 TEST(DWARFDebugInfo, DISABLED_TestAttributeIterators) { 1473 #else 1474 TEST(DWARFDebugInfo, TestAttributeIterators) { 1475 #endif 1476 Triple Triple = getNormalizedDefaultTargetTriple(); 1477 if (!isConfigurationSupported(Triple)) 1478 GTEST_SKIP(); 1479 1480 // Test the DWARF APIs related to iterating across all attribute values in a 1481 // a DWARFDie. 1482 uint16_t Version = 4; 1483 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version); 1484 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded()); 1485 dwarfgen::Generator *DG = ExpectedDG.get().get(); 1486 dwarfgen::CompileUnit &CU = DG->addCompileUnit(); 1487 const uint64_t CULowPC = 0x1000; 1488 StringRef CUPath("/tmp/main.c"); 1489 1490 // Scope to allow us to re-use the same DIE names 1491 { 1492 auto CUDie = CU.getUnitDIE(); 1493 // Encode an attribute value before an attribute with no data. 1494 CUDie.addAttribute(DW_AT_name, DW_FORM_strp, CUPath.data()); 1495 // Encode an attribute value with no data in .debug_info/types to ensure 1496 // the iteration works correctly. 1497 CUDie.addAttribute(DW_AT_declaration, DW_FORM_flag_present); 1498 // Encode an attribute value after an attribute with no data. 1499 CUDie.addAttribute(DW_AT_low_pc, DW_FORM_addr, CULowPC); 1500 } 1501 1502 MemoryBufferRef FileBuffer(DG->generate(), "dwarf"); 1503 auto Obj = object::ObjectFile::createObjectFile(FileBuffer); 1504 EXPECT_TRUE((bool)Obj); 1505 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj); 1506 1507 // Verify the number of compile units is correct. 1508 uint32_t NumCUs = DwarfContext->getNumCompileUnits(); 1509 EXPECT_EQ(NumCUs, 1u); 1510 DWARFCompileUnit *U = 1511 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0)); 1512 1513 // Get the compile unit DIE is valid. 1514 auto CUDie = U->getUnitDIE(false); 1515 EXPECT_TRUE(CUDie.isValid()); 1516 1517 auto R = CUDie.attributes(); 1518 auto I = R.begin(); 1519 auto E = R.end(); 1520 1521 ASSERT_NE(E, I); 1522 EXPECT_EQ(I->Attr, DW_AT_name); 1523 auto ActualCUPath = toString(I->Value); 1524 EXPECT_EQ(CUPath, *ActualCUPath); 1525 1526 ASSERT_NE(E, ++I); 1527 EXPECT_EQ(I->Attr, DW_AT_declaration); 1528 EXPECT_EQ(1ull, *I->Value.getAsUnsignedConstant()); 1529 1530 ASSERT_NE(E, ++I); 1531 EXPECT_EQ(I->Attr, DW_AT_low_pc); 1532 EXPECT_EQ(CULowPC, *I->Value.getAsAddress()); 1533 1534 EXPECT_EQ(E, ++I); 1535 } 1536 1537 #if defined(_AIX) && defined(__64BIT__) 1538 TEST(DWARFDebugInfo, DISABLED_TestFindRecurse) { 1539 #else 1540 TEST(DWARFDebugInfo, TestFindRecurse) { 1541 #endif 1542 Triple Triple = getNormalizedDefaultTargetTriple(); 1543 if (!isConfigurationSupported(Triple)) 1544 GTEST_SKIP(); 1545 1546 uint16_t Version = 4; 1547 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version); 1548 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded()); 1549 dwarfgen::Generator *DG = ExpectedDG.get().get(); 1550 dwarfgen::CompileUnit &CU = DG->addCompileUnit(); 1551 1552 StringRef SpecDieName = "spec"; 1553 StringRef SpecLinkageName = "spec_linkage"; 1554 StringRef AbsDieName = "abs"; 1555 // Scope to allow us to re-use the same DIE names 1556 { 1557 auto CUDie = CU.getUnitDIE(); 1558 auto FuncSpecDie = CUDie.addChild(DW_TAG_subprogram); 1559 auto FuncAbsDie = CUDie.addChild(DW_TAG_subprogram); 1560 // Put the linkage name in a second abstract origin DIE to ensure we 1561 // recurse through more than just one DIE when looking for attributes. 1562 auto FuncAbsDie2 = CUDie.addChild(DW_TAG_subprogram); 1563 auto FuncDie = CUDie.addChild(DW_TAG_subprogram); 1564 auto VarAbsDie = CUDie.addChild(DW_TAG_variable); 1565 auto VarDie = CUDie.addChild(DW_TAG_variable); 1566 FuncSpecDie.addAttribute(DW_AT_name, DW_FORM_strp, SpecDieName); 1567 FuncAbsDie2.addAttribute(DW_AT_linkage_name, DW_FORM_strp, SpecLinkageName); 1568 FuncAbsDie.addAttribute(DW_AT_specification, DW_FORM_ref4, FuncSpecDie); 1569 FuncAbsDie.addAttribute(DW_AT_abstract_origin, DW_FORM_ref4, FuncAbsDie2); 1570 FuncDie.addAttribute(DW_AT_abstract_origin, DW_FORM_ref4, FuncAbsDie); 1571 VarAbsDie.addAttribute(DW_AT_name, DW_FORM_strp, AbsDieName); 1572 VarDie.addAttribute(DW_AT_abstract_origin, DW_FORM_ref4, VarAbsDie); 1573 } 1574 1575 MemoryBufferRef FileBuffer(DG->generate(), "dwarf"); 1576 auto Obj = object::ObjectFile::createObjectFile(FileBuffer); 1577 EXPECT_TRUE((bool)Obj); 1578 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj); 1579 1580 // Verify the number of compile units is correct. 1581 uint32_t NumCUs = DwarfContext->getNumCompileUnits(); 1582 EXPECT_EQ(NumCUs, 1u); 1583 DWARFCompileUnit *U = 1584 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0)); 1585 1586 // Get the compile unit DIE is valid. 1587 auto CUDie = U->getUnitDIE(false); 1588 EXPECT_TRUE(CUDie.isValid()); 1589 1590 auto FuncSpecDie = CUDie.getFirstChild(); 1591 auto FuncAbsDie = FuncSpecDie.getSibling(); 1592 auto FuncAbsDie2 = FuncAbsDie.getSibling(); 1593 auto FuncDie = FuncAbsDie2.getSibling(); 1594 auto VarAbsDie = FuncDie.getSibling(); 1595 auto VarDie = VarAbsDie.getSibling(); 1596 1597 // Make sure we can't extract the name from the specification die when using 1598 // DWARFDie::find() since it won't check the DW_AT_specification DIE. 1599 EXPECT_FALSE(FuncDie.find(DW_AT_name)); 1600 1601 // Make sure we can extract the name from the specification die when using 1602 // DWARFDie::findRecursively() since it should recurse through the 1603 // DW_AT_specification DIE. 1604 auto NameOpt = FuncDie.findRecursively(DW_AT_name); 1605 EXPECT_TRUE(NameOpt); 1606 // Test the dwarf::toString() helper function. 1607 auto StringOpt = toString(NameOpt); 1608 EXPECT_TRUE(StringOpt); 1609 EXPECT_EQ(SpecDieName, StringOpt.getValueOr(nullptr)); 1610 // Test the dwarf::toString() helper function with a default value specified. 1611 EXPECT_EQ(SpecDieName, toString(NameOpt, nullptr)); 1612 1613 auto LinkageNameOpt = FuncDie.findRecursively(DW_AT_linkage_name); 1614 EXPECT_EQ(SpecLinkageName, toString(LinkageNameOpt).getValueOr(nullptr)); 1615 1616 // Make sure we can't extract the name from the abstract origin die when using 1617 // DWARFDie::find() since it won't check the DW_AT_abstract_origin DIE. 1618 EXPECT_FALSE(VarDie.find(DW_AT_name)); 1619 1620 // Make sure we can extract the name from the abstract origin die when using 1621 // DWARFDie::findRecursively() since it should recurse through the 1622 // DW_AT_abstract_origin DIE. 1623 NameOpt = VarDie.findRecursively(DW_AT_name); 1624 EXPECT_TRUE(NameOpt); 1625 // Test the dwarf::toString() helper function. 1626 StringOpt = toString(NameOpt); 1627 EXPECT_TRUE(StringOpt); 1628 EXPECT_EQ(AbsDieName, StringOpt.getValueOr(nullptr)); 1629 } 1630 1631 TEST(DWARFDebugInfo, TestDwarfToFunctions) { 1632 // Test all of the dwarf::toXXX functions that take a 1633 // Optional<DWARFFormValue> and extract the values from it. 1634 uint64_t InvalidU64 = 0xBADBADBADBADBADB; 1635 int64_t InvalidS64 = 0xBADBADBADBADBADB; 1636 1637 // First test that we don't get valid values back when using an optional with 1638 // no value. 1639 Optional<DWARFFormValue> FormValOpt1 = DWARFFormValue(); 1640 EXPECT_FALSE(toString(FormValOpt1).hasValue()); 1641 EXPECT_FALSE(toUnsigned(FormValOpt1).hasValue()); 1642 EXPECT_FALSE(toReference(FormValOpt1).hasValue()); 1643 EXPECT_FALSE(toSigned(FormValOpt1).hasValue()); 1644 EXPECT_FALSE(toAddress(FormValOpt1).hasValue()); 1645 EXPECT_FALSE(toSectionOffset(FormValOpt1).hasValue()); 1646 EXPECT_FALSE(toBlock(FormValOpt1).hasValue()); 1647 EXPECT_EQ(nullptr, toString(FormValOpt1, nullptr)); 1648 EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt1, InvalidU64)); 1649 EXPECT_EQ(InvalidU64, toReference(FormValOpt1, InvalidU64)); 1650 EXPECT_EQ(InvalidU64, toAddress(FormValOpt1, InvalidU64)); 1651 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt1, InvalidU64)); 1652 EXPECT_EQ(InvalidS64, toSigned(FormValOpt1, InvalidS64)); 1653 1654 // Test successful and unsuccessful address decoding. 1655 uint64_t Address = 0x100000000ULL; 1656 Optional<DWARFFormValue> FormValOpt2 = 1657 DWARFFormValue::createFromUValue(DW_FORM_addr, Address); 1658 1659 EXPECT_FALSE(toString(FormValOpt2).hasValue()); 1660 EXPECT_FALSE(toUnsigned(FormValOpt2).hasValue()); 1661 EXPECT_FALSE(toReference(FormValOpt2).hasValue()); 1662 EXPECT_FALSE(toSigned(FormValOpt2).hasValue()); 1663 EXPECT_TRUE(toAddress(FormValOpt2).hasValue()); 1664 EXPECT_FALSE(toSectionOffset(FormValOpt2).hasValue()); 1665 EXPECT_FALSE(toBlock(FormValOpt2).hasValue()); 1666 EXPECT_EQ(nullptr, toString(FormValOpt2, nullptr)); 1667 EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt2, InvalidU64)); 1668 EXPECT_EQ(InvalidU64, toReference(FormValOpt2, InvalidU64)); 1669 EXPECT_EQ(Address, toAddress(FormValOpt2, InvalidU64)); 1670 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt2, InvalidU64)); 1671 EXPECT_EQ(InvalidS64, toSigned(FormValOpt2, InvalidU64)); 1672 1673 // Test successful and unsuccessful unsigned constant decoding. 1674 uint64_t UData8 = 0x1020304050607080ULL; 1675 Optional<DWARFFormValue> FormValOpt3 = 1676 DWARFFormValue::createFromUValue(DW_FORM_udata, UData8); 1677 1678 EXPECT_FALSE(toString(FormValOpt3).hasValue()); 1679 EXPECT_TRUE(toUnsigned(FormValOpt3).hasValue()); 1680 EXPECT_FALSE(toReference(FormValOpt3).hasValue()); 1681 EXPECT_TRUE(toSigned(FormValOpt3).hasValue()); 1682 EXPECT_FALSE(toAddress(FormValOpt3).hasValue()); 1683 EXPECT_FALSE(toSectionOffset(FormValOpt3).hasValue()); 1684 EXPECT_FALSE(toBlock(FormValOpt3).hasValue()); 1685 EXPECT_EQ(nullptr, toString(FormValOpt3, nullptr)); 1686 EXPECT_EQ(UData8, toUnsigned(FormValOpt3, InvalidU64)); 1687 EXPECT_EQ(InvalidU64, toReference(FormValOpt3, InvalidU64)); 1688 EXPECT_EQ(InvalidU64, toAddress(FormValOpt3, InvalidU64)); 1689 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt3, InvalidU64)); 1690 EXPECT_EQ((int64_t)UData8, toSigned(FormValOpt3, InvalidU64)); 1691 1692 // Test successful and unsuccessful reference decoding. 1693 uint32_t RefData = 0x11223344U; 1694 Optional<DWARFFormValue> FormValOpt4 = 1695 DWARFFormValue::createFromUValue(DW_FORM_ref_addr, RefData); 1696 1697 EXPECT_FALSE(toString(FormValOpt4).hasValue()); 1698 EXPECT_FALSE(toUnsigned(FormValOpt4).hasValue()); 1699 EXPECT_TRUE(toReference(FormValOpt4).hasValue()); 1700 EXPECT_FALSE(toSigned(FormValOpt4).hasValue()); 1701 EXPECT_FALSE(toAddress(FormValOpt4).hasValue()); 1702 EXPECT_FALSE(toSectionOffset(FormValOpt4).hasValue()); 1703 EXPECT_FALSE(toBlock(FormValOpt4).hasValue()); 1704 EXPECT_EQ(nullptr, toString(FormValOpt4, nullptr)); 1705 EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt4, InvalidU64)); 1706 EXPECT_EQ(RefData, toReference(FormValOpt4, InvalidU64)); 1707 EXPECT_EQ(InvalidU64, toAddress(FormValOpt4, InvalidU64)); 1708 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt4, InvalidU64)); 1709 EXPECT_EQ(InvalidS64, toSigned(FormValOpt4, InvalidU64)); 1710 1711 // Test successful and unsuccessful signed constant decoding. 1712 int64_t SData8 = 0x1020304050607080ULL; 1713 Optional<DWARFFormValue> FormValOpt5 = 1714 DWARFFormValue::createFromSValue(DW_FORM_udata, SData8); 1715 1716 EXPECT_FALSE(toString(FormValOpt5).hasValue()); 1717 EXPECT_TRUE(toUnsigned(FormValOpt5).hasValue()); 1718 EXPECT_FALSE(toReference(FormValOpt5).hasValue()); 1719 EXPECT_TRUE(toSigned(FormValOpt5).hasValue()); 1720 EXPECT_FALSE(toAddress(FormValOpt5).hasValue()); 1721 EXPECT_FALSE(toSectionOffset(FormValOpt5).hasValue()); 1722 EXPECT_FALSE(toBlock(FormValOpt5).hasValue()); 1723 EXPECT_EQ(nullptr, toString(FormValOpt5, nullptr)); 1724 EXPECT_EQ((uint64_t)SData8, toUnsigned(FormValOpt5, InvalidU64)); 1725 EXPECT_EQ(InvalidU64, toReference(FormValOpt5, InvalidU64)); 1726 EXPECT_EQ(InvalidU64, toAddress(FormValOpt5, InvalidU64)); 1727 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt5, InvalidU64)); 1728 EXPECT_EQ(SData8, toSigned(FormValOpt5, InvalidU64)); 1729 1730 // Test successful and unsuccessful block decoding. 1731 uint8_t Data[] = { 2, 3, 4 }; 1732 ArrayRef<uint8_t> Array(Data); 1733 Optional<DWARFFormValue> FormValOpt6 = 1734 DWARFFormValue::createFromBlockValue(DW_FORM_block1, Array); 1735 1736 EXPECT_FALSE(toString(FormValOpt6).hasValue()); 1737 EXPECT_FALSE(toUnsigned(FormValOpt6).hasValue()); 1738 EXPECT_FALSE(toReference(FormValOpt6).hasValue()); 1739 EXPECT_FALSE(toSigned(FormValOpt6).hasValue()); 1740 EXPECT_FALSE(toAddress(FormValOpt6).hasValue()); 1741 EXPECT_FALSE(toSectionOffset(FormValOpt6).hasValue()); 1742 auto BlockOpt = toBlock(FormValOpt6); 1743 EXPECT_TRUE(BlockOpt.hasValue()); 1744 EXPECT_EQ(*BlockOpt, Array); 1745 EXPECT_EQ(nullptr, toString(FormValOpt6, nullptr)); 1746 EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt6, InvalidU64)); 1747 EXPECT_EQ(InvalidU64, toReference(FormValOpt6, InvalidU64)); 1748 EXPECT_EQ(InvalidU64, toAddress(FormValOpt6, InvalidU64)); 1749 EXPECT_EQ(InvalidU64, toSectionOffset(FormValOpt6, InvalidU64)); 1750 EXPECT_EQ(InvalidS64, toSigned(FormValOpt6, InvalidU64)); 1751 1752 // Test 1753 } 1754 1755 #if defined(_AIX) && defined(__64BIT__) 1756 TEST(DWARFDebugInfo, DISABLED_TestFindAttrs) { 1757 #else 1758 TEST(DWARFDebugInfo, TestFindAttrs) { 1759 #endif 1760 Triple Triple = getNormalizedDefaultTargetTriple(); 1761 if (!isConfigurationSupported(Triple)) 1762 GTEST_SKIP(); 1763 1764 // Test the DWARFDie::find() and DWARFDie::findRecursively() that take an 1765 // ArrayRef<dwarf::Attribute> value to make sure they work correctly. 1766 uint16_t Version = 4; 1767 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version); 1768 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded()); 1769 dwarfgen::Generator *DG = ExpectedDG.get().get(); 1770 dwarfgen::CompileUnit &CU = DG->addCompileUnit(); 1771 1772 StringRef DieMangled("_Z3fooi"); 1773 // Scope to allow us to re-use the same DIE names 1774 { 1775 auto CUDie = CU.getUnitDIE(); 1776 auto FuncSpecDie = CUDie.addChild(DW_TAG_subprogram); 1777 auto FuncDie = CUDie.addChild(DW_TAG_subprogram); 1778 FuncSpecDie.addAttribute(DW_AT_MIPS_linkage_name, DW_FORM_strp, DieMangled); 1779 FuncDie.addAttribute(DW_AT_specification, DW_FORM_ref4, FuncSpecDie); 1780 } 1781 1782 MemoryBufferRef FileBuffer(DG->generate(), "dwarf"); 1783 auto Obj = object::ObjectFile::createObjectFile(FileBuffer); 1784 EXPECT_TRUE((bool)Obj); 1785 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj); 1786 1787 // Verify the number of compile units is correct. 1788 uint32_t NumCUs = DwarfContext->getNumCompileUnits(); 1789 EXPECT_EQ(NumCUs, 1u); 1790 DWARFCompileUnit *U = 1791 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0)); 1792 1793 // Get the compile unit DIE is valid. 1794 auto CUDie = U->getUnitDIE(false); 1795 EXPECT_TRUE(CUDie.isValid()); 1796 1797 auto FuncSpecDie = CUDie.getFirstChild(); 1798 auto FuncDie = FuncSpecDie.getSibling(); 1799 1800 // Make sure that passing in an empty attribute list behave correctly. 1801 EXPECT_FALSE(FuncDie.find(ArrayRef<dwarf::Attribute>()).hasValue()); 1802 1803 // Make sure that passing in a list of attribute that are not contained 1804 // in the DIE returns nothing. 1805 EXPECT_FALSE(FuncDie.find({DW_AT_low_pc, DW_AT_entry_pc}).hasValue()); 1806 1807 const dwarf::Attribute Attrs[] = {DW_AT_linkage_name, 1808 DW_AT_MIPS_linkage_name}; 1809 1810 // Make sure we can't extract the linkage name attributes when using 1811 // DWARFDie::find() since it won't check the DW_AT_specification DIE. 1812 EXPECT_FALSE(FuncDie.find(Attrs).hasValue()); 1813 1814 // Make sure we can extract the name from the specification die when using 1815 // DWARFDie::findRecursively() since it should recurse through the 1816 // DW_AT_specification DIE. 1817 auto NameOpt = FuncDie.findRecursively(Attrs); 1818 EXPECT_TRUE(NameOpt.hasValue()); 1819 EXPECT_EQ(DieMangled, toString(NameOpt, "")); 1820 } 1821 1822 #if defined(_AIX) && defined(__64BIT__) 1823 TEST(DWARFDebugInfo, DISABLED_TestImplicitConstAbbrevs) { 1824 #else 1825 TEST(DWARFDebugInfo, TestImplicitConstAbbrevs) { 1826 #endif 1827 Triple Triple = getNormalizedDefaultTargetTriple(); 1828 if (!isConfigurationSupported(Triple)) 1829 GTEST_SKIP(); 1830 1831 uint16_t Version = 5; 1832 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version); 1833 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded()); 1834 dwarfgen::Generator *DG = ExpectedDG.get().get(); 1835 dwarfgen::CompileUnit &CU = DG->addCompileUnit(); 1836 dwarfgen::DIE CUDie = CU.getUnitDIE(); 1837 const dwarf::Attribute Attr = DW_AT_lo_user; 1838 const int64_t Val1 = 42; 1839 const int64_t Val2 = 43; 1840 1841 auto FirstVal1DIE = CUDie.addChild(DW_TAG_class_type); 1842 FirstVal1DIE.addAttribute(Attr, DW_FORM_implicit_const, Val1); 1843 1844 auto SecondVal1DIE = CUDie.addChild(DW_TAG_class_type); 1845 SecondVal1DIE.addAttribute(Attr, DW_FORM_implicit_const, Val1); 1846 1847 auto Val2DIE = CUDie.addChild(DW_TAG_class_type); 1848 Val2DIE.addAttribute(Attr, DW_FORM_implicit_const, Val2); 1849 1850 MemoryBufferRef FileBuffer(DG->generate(), "dwarf"); 1851 auto Obj = object::ObjectFile::createObjectFile(FileBuffer); 1852 EXPECT_TRUE((bool)Obj); 1853 std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(**Obj); 1854 DWARFCompileUnit *U = 1855 cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0)); 1856 EXPECT_TRUE((bool)U); 1857 1858 const auto *Abbrevs = U->getAbbreviations(); 1859 EXPECT_TRUE((bool)Abbrevs); 1860 1861 // Let's find implicit_const abbrevs and verify, 1862 // that there are exactly two of them and both of them 1863 // can be dumped correctly. 1864 typedef decltype(Abbrevs->begin()) AbbrevIt; 1865 AbbrevIt Val1Abbrev = Abbrevs->end(); 1866 AbbrevIt Val2Abbrev = Abbrevs->end(); 1867 for(auto it = Abbrevs->begin(); it != Abbrevs->end(); ++it) { 1868 if (it->getNumAttributes() == 0) 1869 continue; // root abbrev for DW_TAG_compile_unit 1870 1871 auto A = it->getAttrByIndex(0); 1872 EXPECT_EQ(A, Attr); 1873 1874 Optional<uint32_t> AttrIndex = it->findAttributeIndex(A); 1875 EXPECT_TRUE((bool)AttrIndex); 1876 EXPECT_EQ(*AttrIndex, 0u); 1877 uint64_t OffsetVal = 1878 it->getAttributeOffsetFromIndex(*AttrIndex, /* offset */ 0, *U); 1879 EXPECT_TRUE( 1880 it->getAttributeValueFromOffset(*AttrIndex, OffsetVal, *U).hasValue()); 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, TestErrorReporting) { 1952 Triple Triple("x86_64-pc-linux"); 1953 if (!isConfigurationSupported(Triple)) 1954 GTEST_SKIP(); 1955 1956 auto ExpectedDG = dwarfgen::Generator::create(Triple, 4 /*DwarfVersion*/); 1957 ASSERT_THAT_EXPECTED(ExpectedDG, Succeeded()); 1958 dwarfgen::Generator *DG = ExpectedDG.get().get(); 1959 AsmPrinter *AP = DG->getAsmPrinter(); 1960 MCContext *MC = DG->getMCContext(); 1961 1962 // Emit two compressed sections with broken headers. 1963 AP->OutStreamer->SwitchSection( 1964 MC->getELFSection(".zdebug_foo", 0 /*Type*/, 0 /*Flags*/)); 1965 AP->OutStreamer->emitBytes("0"); 1966 AP->OutStreamer->SwitchSection( 1967 MC->getELFSection(".zdebug_bar", 0 /*Type*/, 0 /*Flags*/)); 1968 AP->OutStreamer->emitBytes("0"); 1969 1970 MemoryBufferRef FileBuffer(DG->generate(), "dwarf"); 1971 auto Obj = object::ObjectFile::createObjectFile(FileBuffer); 1972 EXPECT_TRUE((bool)Obj); 1973 1974 // DWARFContext parses whole file and finds the two errors we expect. 1975 int Errors = 0; 1976 std::unique_ptr<DWARFContext> Ctx1 = DWARFContext::create( 1977 **Obj, DWARFContext::ProcessDebugRelocations::Process, nullptr, "", 1978 [&](Error E) { 1979 ++Errors; 1980 consumeError(std::move(E)); 1981 }); 1982 EXPECT_TRUE(Errors == 2); 1983 } 1984 1985 TEST(DWARFDebugInfo, TestDWARFDieRangeInfoContains) { 1986 DWARFVerifier::DieRangeInfo Empty; 1987 ASSERT_TRUE(Empty.contains(Empty)); 1988 1989 DWARFVerifier::DieRangeInfo Ranges( 1990 {{0x10, 0x20}, {0x30, 0x40}, {0x40, 0x50}}); 1991 1992 ASSERT_TRUE(Ranges.contains(Empty)); 1993 ASSERT_FALSE(Ranges.contains({{{0x0f, 0x10}}})); 1994 ASSERT_FALSE(Ranges.contains({{{0x0f, 0x20}}})); 1995 ASSERT_FALSE(Ranges.contains({{{0x0f, 0x21}}})); 1996 1997 // Test ranges that start at R's start address 1998 ASSERT_TRUE(Ranges.contains({{{0x10, 0x10}}})); 1999 ASSERT_TRUE(Ranges.contains({{{0x10, 0x11}}})); 2000 ASSERT_TRUE(Ranges.contains({{{0x10, 0x20}}})); 2001 ASSERT_FALSE(Ranges.contains({{{0x10, 0x21}}})); 2002 2003 ASSERT_TRUE(Ranges.contains({{{0x11, 0x12}}})); 2004 2005 // Test ranges that start at last bytes of Range 2006 ASSERT_TRUE(Ranges.contains({{{0x1f, 0x20}}})); 2007 ASSERT_FALSE(Ranges.contains({{{0x1f, 0x21}}})); 2008 2009 // Test ranges that start after Range 2010 ASSERT_TRUE(Ranges.contains({{{0x20, 0x20}}})); 2011 ASSERT_FALSE(Ranges.contains({{{0x20, 0x21}}})); 2012 2013 ASSERT_TRUE(Ranges.contains({{{0x31, 0x32}}})); 2014 ASSERT_TRUE(Ranges.contains({{{0x3f, 0x40}}})); 2015 ASSERT_TRUE(Ranges.contains({{{0x10, 0x20}, {0x30, 0x40}}})); 2016 ASSERT_TRUE(Ranges.contains({{{0x11, 0x12}, {0x31, 0x32}}})); 2017 ASSERT_TRUE(Ranges.contains( 2018 {{{0x11, 0x12}, {0x12, 0x13}, {0x31, 0x32}, {0x32, 0x33}}})); 2019 ASSERT_FALSE(Ranges.contains({{{0x11, 0x12}, 2020 {0x12, 0x13}, 2021 {0x20, 0x21}, 2022 {0x31, 0x32}, 2023 {0x32, 0x33}}})); 2024 ASSERT_FALSE(Ranges.contains( 2025 {{{0x11, 0x12}, {0x12, 0x13}, {0x31, 0x32}, {0x32, 0x51}}})); 2026 ASSERT_TRUE(Ranges.contains({{{0x11, 0x12}, {0x30, 0x50}}})); 2027 ASSERT_FALSE(Ranges.contains({{{0x30, 0x51}}})); 2028 ASSERT_FALSE(Ranges.contains({{{0x50, 0x51}}})); 2029 } 2030 2031 namespace { 2032 2033 void AssertRangesIntersect(const DWARFAddressRange &LHS, 2034 const DWARFAddressRange &RHS) { 2035 ASSERT_TRUE(LHS.intersects(RHS)); 2036 ASSERT_TRUE(RHS.intersects(LHS)); 2037 } 2038 void AssertRangesDontIntersect(const DWARFAddressRange &LHS, 2039 const DWARFAddressRange &RHS) { 2040 ASSERT_FALSE(LHS.intersects(RHS)); 2041 ASSERT_FALSE(RHS.intersects(LHS)); 2042 } 2043 2044 void AssertRangesIntersect(const DWARFVerifier::DieRangeInfo &LHS, 2045 const DWARFAddressRangesVector &Ranges) { 2046 DWARFVerifier::DieRangeInfo RHS(Ranges); 2047 ASSERT_TRUE(LHS.intersects(RHS)); 2048 ASSERT_TRUE(RHS.intersects(LHS)); 2049 } 2050 2051 void AssertRangesDontIntersect(const DWARFVerifier::DieRangeInfo &LHS, 2052 const DWARFAddressRangesVector &Ranges) { 2053 DWARFVerifier::DieRangeInfo RHS(Ranges); 2054 ASSERT_FALSE(LHS.intersects(RHS)); 2055 ASSERT_FALSE(RHS.intersects(LHS)); 2056 } 2057 2058 } // namespace 2059 TEST(DWARFDebugInfo, TestDwarfRangesIntersect) { 2060 DWARFAddressRange R(0x10, 0x20); 2061 2062 //---------------------------------------------------------------------- 2063 // Test ranges that start before R... 2064 //---------------------------------------------------------------------- 2065 // Other range ends before start of R 2066 AssertRangesDontIntersect(R, {0x00, 0x10}); 2067 // Other range end address is start of a R 2068 AssertRangesIntersect(R, {0x00, 0x11}); 2069 // Other range end address is in R 2070 AssertRangesIntersect(R, {0x00, 0x15}); 2071 // Other range end address is at and of R 2072 AssertRangesIntersect(R, {0x00, 0x20}); 2073 // Other range end address is past end of R 2074 AssertRangesIntersect(R, {0x00, 0x40}); 2075 2076 //---------------------------------------------------------------------- 2077 // Test ranges that start at R's start address 2078 //---------------------------------------------------------------------- 2079 // Ensure empty ranges doesn't match 2080 AssertRangesDontIntersect(R, {0x10, 0x10}); 2081 // 1 byte of Range 2082 AssertRangesIntersect(R, {0x10, 0x11}); 2083 // same as Range 2084 AssertRangesIntersect(R, {0x10, 0x20}); 2085 // 1 byte past Range 2086 AssertRangesIntersect(R, {0x10, 0x21}); 2087 2088 //---------------------------------------------------------------------- 2089 // Test ranges that start inside Range 2090 //---------------------------------------------------------------------- 2091 // empty in range 2092 AssertRangesDontIntersect(R, {0x11, 0x11}); 2093 // all in Range 2094 AssertRangesIntersect(R, {0x11, 0x1f}); 2095 // ends at end of Range 2096 AssertRangesIntersect(R, {0x11, 0x20}); 2097 // ends past Range 2098 AssertRangesIntersect(R, {0x11, 0x21}); 2099 2100 //---------------------------------------------------------------------- 2101 // Test ranges that start at last bytes of Range 2102 //---------------------------------------------------------------------- 2103 // ends at end of Range 2104 AssertRangesIntersect(R, {0x1f, 0x20}); 2105 // ends past Range 2106 AssertRangesIntersect(R, {0x1f, 0x21}); 2107 2108 //---------------------------------------------------------------------- 2109 // Test ranges that start after Range 2110 //---------------------------------------------------------------------- 2111 // empty just past in Range 2112 AssertRangesDontIntersect(R, {0x20, 0x20}); 2113 // valid past Range 2114 AssertRangesDontIntersect(R, {0x20, 0x21}); 2115 } 2116 2117 TEST(DWARFDebugInfo, TestDWARFDieRangeInfoIntersects) { 2118 2119 DWARFVerifier::DieRangeInfo Ranges({{0x10, 0x20}, {0x30, 0x40}}); 2120 2121 // Test empty range 2122 AssertRangesDontIntersect(Ranges, {}); 2123 // Test range that appears before all ranges in Ranges 2124 AssertRangesDontIntersect(Ranges, {{0x00, 0x10}}); 2125 // Test range that appears between ranges in Ranges 2126 AssertRangesDontIntersect(Ranges, {{0x20, 0x30}}); 2127 // Test range that appears after ranges in Ranges 2128 AssertRangesDontIntersect(Ranges, {{0x40, 0x50}}); 2129 2130 // Test range that start before first range 2131 AssertRangesIntersect(Ranges, {{0x00, 0x11}}); 2132 // Test range that start at first range 2133 AssertRangesIntersect(Ranges, {{0x10, 0x11}}); 2134 // Test range that start in first range 2135 AssertRangesIntersect(Ranges, {{0x11, 0x12}}); 2136 // Test range that start at end of first range 2137 AssertRangesIntersect(Ranges, {{0x1f, 0x20}}); 2138 // Test range that starts at end of first range 2139 AssertRangesDontIntersect(Ranges, {{0x20, 0x21}}); 2140 // Test range that starts at end of first range 2141 AssertRangesIntersect(Ranges, {{0x20, 0x31}}); 2142 2143 // Test range that start before second range and ends before second 2144 AssertRangesDontIntersect(Ranges, {{0x2f, 0x30}}); 2145 // Test range that start before second range and ends in second 2146 AssertRangesIntersect(Ranges, {{0x2f, 0x31}}); 2147 // Test range that start at second range 2148 AssertRangesIntersect(Ranges, {{0x30, 0x31}}); 2149 // Test range that start in second range 2150 AssertRangesIntersect(Ranges, {{0x31, 0x32}}); 2151 // Test range that start at end of second range 2152 AssertRangesIntersect(Ranges, {{0x3f, 0x40}}); 2153 // Test range that starts at end of second range 2154 AssertRangesDontIntersect(Ranges, {{0x40, 0x41}}); 2155 2156 AssertRangesDontIntersect(Ranges, {{0x20, 0x21}, {0x2f, 0x30}}); 2157 AssertRangesIntersect(Ranges, {{0x20, 0x21}, {0x2f, 0x31}}); 2158 } 2159 2160 TEST(DWARFDebugInfo, TestDWARF64UnitLength) { 2161 static const char DebugInfoSecRaw[] = 2162 "\xff\xff\xff\xff" // DWARF64 mark 2163 "\x88\x77\x66\x55\x44\x33\x22\x11" // Length 2164 "\x05\x00" // Version 2165 "\x01" // DW_UT_compile 2166 "\x04" // Address size 2167 "\0\0\0\0\0\0\0\0"; // Offset Into Abbrev. Sec. 2168 StringMap<std::unique_ptr<MemoryBuffer>> Sections; 2169 Sections.insert(std::make_pair( 2170 "debug_info", MemoryBuffer::getMemBuffer(StringRef( 2171 DebugInfoSecRaw, sizeof(DebugInfoSecRaw) - 1)))); 2172 auto Context = DWARFContext::create(Sections, /* AddrSize = */ 4, 2173 /* isLittleEndian = */ true); 2174 const auto &Obj = Context->getDWARFObj(); 2175 Obj.forEachInfoSections([&](const DWARFSection &Sec) { 2176 DWARFUnitHeader Header; 2177 DWARFDataExtractor Data(Obj, Sec, /* IsLittleEndian = */ true, 2178 /* AddressSize = */ 4); 2179 uint64_t Offset = 0; 2180 EXPECT_FALSE(Header.extract(*Context, Data, &Offset, DW_SECT_INFO)); 2181 // Header.extract() returns false because there is not enough space 2182 // in the section for the declared length. Anyway, we can check that 2183 // the properties are read correctly. 2184 ASSERT_EQ(DwarfFormat::DWARF64, Header.getFormat()); 2185 ASSERT_EQ(0x1122334455667788ULL, Header.getLength()); 2186 ASSERT_EQ(5, Header.getVersion()); 2187 ASSERT_EQ(DW_UT_compile, Header.getUnitType()); 2188 ASSERT_EQ(4, Header.getAddressByteSize()); 2189 2190 // Check that the length can be correctly read in the unit class. 2191 DWARFUnitVector DummyUnitVector; 2192 DWARFSection DummySec; 2193 DWARFCompileUnit CU(*Context, Sec, Header, /* DA = */ 0, /* RS = */ 0, 2194 /* LocSection = */ 0, /* SS = */ StringRef(), 2195 /* SOS = */ DummySec, /* AOS = */ 0, 2196 /* LS = */ DummySec, /* LE = */ true, 2197 /* isDWO= */ false, DummyUnitVector); 2198 ASSERT_EQ(0x1122334455667788ULL, CU.getLength()); 2199 }); 2200 } 2201 2202 } // end anonymous namespace 2203