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