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