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