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