1 //===- llvm/unittest/DebugInfo/DWARFFormValueTest.cpp ---------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "DwarfGenerator.h" 11 #include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h" 12 #include "llvm/DebugInfo/DWARF/DWARFContext.h" 13 #include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h" 14 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h" 15 #include "llvm/DebugInfo/DWARF/DWARFUnit.h" 16 #include "llvm/Support/Dwarf.h" 17 #include "llvm/Support/Host.h" 18 #include "llvm/Support/TargetSelect.h" 19 #include "gtest/gtest.h" 20 #include <climits> 21 22 using namespace llvm; 23 using namespace dwarf; 24 25 namespace { 26 27 void initLLVMIfNeeded() { 28 static bool gInitialized = false; 29 if (!gInitialized) { 30 gInitialized = true; 31 InitializeAllTargets(); 32 InitializeAllTargetMCs(); 33 InitializeAllAsmPrinters(); 34 InitializeAllAsmParsers(); 35 } 36 } 37 38 Triple getHostTripleForAddrSize(uint8_t AddrSize) { 39 Triple PT(Triple::normalize(LLVM_HOST_TRIPLE)); 40 41 if (AddrSize == 8 && PT.isArch32Bit()) 42 return PT.get64BitArchVariant(); 43 if (AddrSize == 4 && PT.isArch64Bit()) 44 return PT.get32BitArchVariant(); 45 return PT; 46 } 47 48 /// Take any llvm::Expected and check and handle any errors. 49 /// 50 /// \param Expected a llvm::Excepted instance to check. 51 /// \returns true if there were errors, false otherwise. 52 template <typename T> 53 static bool HandleExpectedError(T &Expected) { 54 std::string ErrorMsg; 55 handleAllErrors(Expected.takeError(), [&](const llvm::ErrorInfoBase &EI) { 56 ErrorMsg = EI.message(); 57 }); 58 if (!ErrorMsg.empty()) { 59 ::testing::AssertionFailure() << "error: " << ErrorMsg; 60 return true; 61 } 62 return false; 63 } 64 65 template <uint16_t Version, class AddrType, class RefAddrType> 66 void TestAllForms() { 67 // Test that we can decode all DW_FORM values correctly. 68 69 const uint8_t AddrSize = sizeof(AddrType); 70 const AddrType AddrValue = (AddrType)0x0123456789abcdefULL; 71 const uint8_t BlockData[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}; 72 const uint32_t BlockSize = sizeof(BlockData); 73 const RefAddrType RefAddr = 0x12345678; 74 const uint8_t Data1 = 0x01U; 75 const uint16_t Data2 = 0x2345U; 76 const uint32_t Data4 = 0x6789abcdU; 77 const uint64_t Data8 = 0x0011223344556677ULL; 78 const uint64_t Data8_2 = 0xAABBCCDDEEFF0011ULL; 79 const int64_t SData = INT64_MIN; 80 const uint64_t UData[] = {UINT64_MAX - 1, UINT64_MAX - 2, UINT64_MAX - 3, 81 UINT64_MAX - 4, UINT64_MAX - 5, UINT64_MAX - 6, 82 UINT64_MAX - 7, UINT64_MAX - 8, UINT64_MAX - 9}; 83 #define UDATA_1 18446744073709551614ULL 84 const uint32_t Dwarf32Values[] = {1, 2, 3, 4, 5, 6, 7, 8}; 85 const char *StringValue = "Hello"; 86 const char *StrpValue = "World"; 87 initLLVMIfNeeded(); 88 Triple Triple = getHostTripleForAddrSize(AddrSize); 89 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version); 90 if (HandleExpectedError(ExpectedDG)) 91 return; 92 dwarfgen::Generator *DG = ExpectedDG.get().get(); 93 dwarfgen::CompileUnit &CU = DG->addCompileUnit(); 94 dwarfgen::DIE CUDie = CU.getUnitDIE(); 95 uint16_t Attr = DW_AT_lo_user; 96 97 //---------------------------------------------------------------------- 98 // Test address forms 99 //---------------------------------------------------------------------- 100 const auto Attr_DW_FORM_addr = static_cast<dwarf::Attribute>(Attr++); 101 CUDie.addAttribute(Attr_DW_FORM_addr, DW_FORM_addr, AddrValue); 102 103 //---------------------------------------------------------------------- 104 // Test block forms 105 //---------------------------------------------------------------------- 106 const auto Attr_DW_FORM_block = static_cast<dwarf::Attribute>(Attr++); 107 CUDie.addAttribute(Attr_DW_FORM_block, DW_FORM_block, BlockData, BlockSize); 108 109 const auto Attr_DW_FORM_block1 = static_cast<dwarf::Attribute>(Attr++); 110 CUDie.addAttribute(Attr_DW_FORM_block1, DW_FORM_block1, BlockData, BlockSize); 111 112 const auto Attr_DW_FORM_block2 = static_cast<dwarf::Attribute>(Attr++); 113 CUDie.addAttribute(Attr_DW_FORM_block2, DW_FORM_block2, BlockData, BlockSize); 114 115 const auto Attr_DW_FORM_block4 = static_cast<dwarf::Attribute>(Attr++); 116 CUDie.addAttribute(Attr_DW_FORM_block4, DW_FORM_block4, BlockData, BlockSize); 117 118 //---------------------------------------------------------------------- 119 // Test data forms 120 //---------------------------------------------------------------------- 121 const auto Attr_DW_FORM_data1 = static_cast<dwarf::Attribute>(Attr++); 122 CUDie.addAttribute(Attr_DW_FORM_data1, DW_FORM_data1, Data1); 123 124 const auto Attr_DW_FORM_data2 = static_cast<dwarf::Attribute>(Attr++); 125 CUDie.addAttribute(Attr_DW_FORM_data2, DW_FORM_data2, Data2); 126 127 const auto Attr_DW_FORM_data4 = static_cast<dwarf::Attribute>(Attr++); 128 CUDie.addAttribute(Attr_DW_FORM_data4, DW_FORM_data4, Data4); 129 130 const auto Attr_DW_FORM_data8 = static_cast<dwarf::Attribute>(Attr++); 131 CUDie.addAttribute(Attr_DW_FORM_data8, DW_FORM_data8, Data8); 132 133 //---------------------------------------------------------------------- 134 // Test string forms 135 //---------------------------------------------------------------------- 136 const auto Attr_DW_FORM_string = static_cast<dwarf::Attribute>(Attr++); 137 CUDie.addAttribute(Attr_DW_FORM_string, DW_FORM_string, StringValue); 138 139 const auto Attr_DW_FORM_strp = static_cast<dwarf::Attribute>(Attr++); 140 CUDie.addAttribute(Attr_DW_FORM_strp, DW_FORM_strp, StrpValue); 141 142 //---------------------------------------------------------------------- 143 // Test reference forms 144 //---------------------------------------------------------------------- 145 const auto Attr_DW_FORM_ref_addr = static_cast<dwarf::Attribute>(Attr++); 146 CUDie.addAttribute(Attr_DW_FORM_ref_addr, DW_FORM_ref_addr, RefAddr); 147 148 const auto Attr_DW_FORM_ref1 = static_cast<dwarf::Attribute>(Attr++); 149 CUDie.addAttribute(Attr_DW_FORM_ref1, DW_FORM_ref1, Data1); 150 151 const auto Attr_DW_FORM_ref2 = static_cast<dwarf::Attribute>(Attr++); 152 CUDie.addAttribute(Attr_DW_FORM_ref2, DW_FORM_ref2, Data2); 153 154 const auto Attr_DW_FORM_ref4 = static_cast<dwarf::Attribute>(Attr++); 155 CUDie.addAttribute(Attr_DW_FORM_ref4, DW_FORM_ref4, Data4); 156 157 const auto Attr_DW_FORM_ref8 = static_cast<dwarf::Attribute>(Attr++); 158 CUDie.addAttribute(Attr_DW_FORM_ref8, DW_FORM_ref8, Data8); 159 160 const auto Attr_DW_FORM_ref_sig8 = static_cast<dwarf::Attribute>(Attr++); 161 CUDie.addAttribute(Attr_DW_FORM_ref_sig8, DW_FORM_ref_sig8, Data8_2); 162 163 const auto Attr_DW_FORM_ref_udata = static_cast<dwarf::Attribute>(Attr++); 164 CUDie.addAttribute(Attr_DW_FORM_ref_udata, DW_FORM_ref_udata, UData[0]); 165 166 //---------------------------------------------------------------------- 167 // Test flag forms 168 //---------------------------------------------------------------------- 169 const auto Attr_DW_FORM_flag_true = static_cast<dwarf::Attribute>(Attr++); 170 CUDie.addAttribute(Attr_DW_FORM_flag_true, DW_FORM_flag, true); 171 172 const auto Attr_DW_FORM_flag_false = static_cast<dwarf::Attribute>(Attr++); 173 CUDie.addAttribute(Attr_DW_FORM_flag_false, DW_FORM_flag, false); 174 175 const auto Attr_DW_FORM_flag_present = static_cast<dwarf::Attribute>(Attr++); 176 CUDie.addAttribute(Attr_DW_FORM_flag_present, DW_FORM_flag_present); 177 178 //---------------------------------------------------------------------- 179 // Test SLEB128 based forms 180 //---------------------------------------------------------------------- 181 const auto Attr_DW_FORM_sdata = static_cast<dwarf::Attribute>(Attr++); 182 CUDie.addAttribute(Attr_DW_FORM_sdata, DW_FORM_sdata, SData); 183 184 //---------------------------------------------------------------------- 185 // Test ULEB128 based forms 186 //---------------------------------------------------------------------- 187 const auto Attr_DW_FORM_udata = static_cast<dwarf::Attribute>(Attr++); 188 CUDie.addAttribute(Attr_DW_FORM_udata, DW_FORM_udata, UData[0]); 189 190 //---------------------------------------------------------------------- 191 // Test DWARF32/DWARF64 forms 192 //---------------------------------------------------------------------- 193 const auto Attr_DW_FORM_GNU_ref_alt = static_cast<dwarf::Attribute>(Attr++); 194 CUDie.addAttribute(Attr_DW_FORM_GNU_ref_alt, DW_FORM_GNU_ref_alt, 195 Dwarf32Values[0]); 196 197 const auto Attr_DW_FORM_sec_offset = static_cast<dwarf::Attribute>(Attr++); 198 CUDie.addAttribute(Attr_DW_FORM_sec_offset, DW_FORM_sec_offset, 199 Dwarf32Values[1]); 200 201 //---------------------------------------------------------------------- 202 // Add an address at the end to make sure we can decode this value 203 //---------------------------------------------------------------------- 204 const auto Attr_Last = static_cast<dwarf::Attribute>(Attr++); 205 CUDie.addAttribute(Attr_Last, DW_FORM_addr, AddrValue); 206 207 //---------------------------------------------------------------------- 208 // Generate the DWARF 209 //---------------------------------------------------------------------- 210 StringRef FileBytes = DG->generate(); 211 MemoryBufferRef FileBuffer(FileBytes, "dwarf"); 212 auto Obj = object::ObjectFile::createObjectFile(FileBuffer); 213 EXPECT_TRUE((bool)Obj); 214 DWARFContextInMemory DwarfContext(*Obj.get()); 215 uint32_t NumCUs = DwarfContext.getNumCompileUnits(); 216 EXPECT_EQ(NumCUs, 1u); 217 DWARFCompileUnit *U = DwarfContext.getCompileUnitAtIndex(0); 218 auto DiePtr = U->getUnitDIE(false); 219 EXPECT_TRUE(DiePtr != nullptr); 220 221 //---------------------------------------------------------------------- 222 // Test address forms 223 //---------------------------------------------------------------------- 224 EXPECT_EQ(DiePtr->getAttributeValueAsAddress(U, Attr_DW_FORM_addr, 0), 225 AddrValue); 226 227 //---------------------------------------------------------------------- 228 // Test block forms 229 //---------------------------------------------------------------------- 230 DWARFFormValue FormValue; 231 ArrayRef<uint8_t> ExtractedBlockData; 232 Optional<ArrayRef<uint8_t>> BlockDataOpt; 233 234 EXPECT_TRUE(DiePtr->getAttributeValue(U, Attr_DW_FORM_block, FormValue)); 235 BlockDataOpt = FormValue.getAsBlock(); 236 EXPECT_TRUE(BlockDataOpt.hasValue()); 237 ExtractedBlockData = BlockDataOpt.getValue(); 238 EXPECT_EQ(ExtractedBlockData.size(), BlockSize); 239 EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0); 240 241 EXPECT_TRUE(DiePtr->getAttributeValue(U, Attr_DW_FORM_block1, FormValue)); 242 BlockDataOpt = FormValue.getAsBlock(); 243 EXPECT_TRUE(BlockDataOpt.hasValue()); 244 ExtractedBlockData = BlockDataOpt.getValue(); 245 EXPECT_EQ(ExtractedBlockData.size(), BlockSize); 246 EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0); 247 248 EXPECT_TRUE(DiePtr->getAttributeValue(U, Attr_DW_FORM_block2, FormValue)); 249 BlockDataOpt = FormValue.getAsBlock(); 250 EXPECT_TRUE(BlockDataOpt.hasValue()); 251 ExtractedBlockData = BlockDataOpt.getValue(); 252 EXPECT_EQ(ExtractedBlockData.size(), BlockSize); 253 EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0); 254 255 EXPECT_TRUE(DiePtr->getAttributeValue(U, Attr_DW_FORM_block4, FormValue)); 256 BlockDataOpt = FormValue.getAsBlock(); 257 EXPECT_TRUE(BlockDataOpt.hasValue()); 258 ExtractedBlockData = BlockDataOpt.getValue(); 259 EXPECT_EQ(ExtractedBlockData.size(), BlockSize); 260 EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0); 261 262 //---------------------------------------------------------------------- 263 // Test data forms 264 //---------------------------------------------------------------------- 265 EXPECT_EQ( 266 DiePtr->getAttributeValueAsUnsignedConstant(U, Attr_DW_FORM_data1, 0), 267 Data1); 268 EXPECT_EQ( 269 DiePtr->getAttributeValueAsUnsignedConstant(U, Attr_DW_FORM_data2, 0), 270 Data2); 271 EXPECT_EQ( 272 DiePtr->getAttributeValueAsUnsignedConstant(U, Attr_DW_FORM_data4, 0), 273 Data4); 274 EXPECT_EQ( 275 DiePtr->getAttributeValueAsUnsignedConstant(U, Attr_DW_FORM_data8, 0), 276 Data8); 277 278 //---------------------------------------------------------------------- 279 // Test string forms 280 //---------------------------------------------------------------------- 281 const char *ExtractedStringValue = 282 DiePtr->getAttributeValueAsString(U, Attr_DW_FORM_string, nullptr); 283 EXPECT_TRUE(ExtractedStringValue != nullptr); 284 EXPECT_TRUE(strcmp(StringValue, ExtractedStringValue) == 0); 285 286 const char *ExtractedStrpValue = 287 DiePtr->getAttributeValueAsString(U, Attr_DW_FORM_strp, nullptr); 288 EXPECT_TRUE(ExtractedStrpValue != nullptr); 289 EXPECT_TRUE(strcmp(StrpValue, ExtractedStrpValue) == 0); 290 291 //---------------------------------------------------------------------- 292 // Test reference forms 293 //---------------------------------------------------------------------- 294 EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref_addr, 0), 295 RefAddr); 296 EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref1, 0), 297 Data1); 298 EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref2, 0), 299 Data2); 300 EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref4, 0), 301 Data4); 302 EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref8, 0), 303 Data8); 304 EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref_sig8, 0), 305 Data8_2); 306 EXPECT_EQ(DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_ref_udata, 0), 307 UData[0]); 308 309 //---------------------------------------------------------------------- 310 // Test flag forms 311 //---------------------------------------------------------------------- 312 EXPECT_EQ(DiePtr->getAttributeValueAsUnsignedConstant( 313 U, Attr_DW_FORM_flag_true, 0ULL), 314 1ULL); 315 EXPECT_EQ(DiePtr->getAttributeValueAsUnsignedConstant( 316 U, Attr_DW_FORM_flag_false, 1ULL), 317 0ULL); 318 EXPECT_EQ(DiePtr->getAttributeValueAsUnsignedConstant( 319 U, Attr_DW_FORM_flag_present, 0ULL), 320 1ULL); 321 322 // TODO: test Attr_DW_FORM_implicit_const extraction 323 324 //---------------------------------------------------------------------- 325 // Test SLEB128 based forms 326 //---------------------------------------------------------------------- 327 EXPECT_EQ(DiePtr->getAttributeValueAsSignedConstant(U, Attr_DW_FORM_sdata, 0), 328 SData); 329 330 //---------------------------------------------------------------------- 331 // Test ULEB128 based forms 332 //---------------------------------------------------------------------- 333 EXPECT_EQ( 334 DiePtr->getAttributeValueAsUnsignedConstant(U, Attr_DW_FORM_udata, 0), 335 UData[0]); 336 337 //---------------------------------------------------------------------- 338 // Test DWARF32/DWARF64 forms 339 //---------------------------------------------------------------------- 340 EXPECT_EQ( 341 DiePtr->getAttributeValueAsReference(U, Attr_DW_FORM_GNU_ref_alt, 0), 342 Dwarf32Values[0]); 343 EXPECT_EQ( 344 DiePtr->getAttributeValueAsSectionOffset(U, Attr_DW_FORM_sec_offset, 0), 345 Dwarf32Values[1]); 346 347 //---------------------------------------------------------------------- 348 // Add an address at the end to make sure we can decode this value 349 //---------------------------------------------------------------------- 350 EXPECT_EQ(DiePtr->getAttributeValueAsAddress(U, Attr_Last, 0), AddrValue); 351 } 352 353 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4AllForms) { 354 // Test that we can decode all forms for DWARF32, version 2, with 4 byte 355 // addresses. 356 typedef uint32_t AddrType; 357 // DW_FORM_ref_addr are the same as the address type in DWARF32 version 2. 358 typedef AddrType RefAddrType; 359 TestAllForms<2, AddrType, RefAddrType>(); 360 } 361 362 TEST(DWARFDebugInfo, TestDWARF32Version2Addr8AllForms) { 363 // Test that we can decode all forms for DWARF32, version 2, with 4 byte 364 // addresses. 365 typedef uint64_t AddrType; 366 // DW_FORM_ref_addr are the same as the address type in DWARF32 version 2. 367 typedef AddrType RefAddrType; 368 TestAllForms<2, AddrType, RefAddrType>(); 369 } 370 371 TEST(DWARFDebugInfo, TestDWARF32Version3Addr4AllForms) { 372 // Test that we can decode all forms for DWARF32, version 3, with 4 byte 373 // addresses. 374 typedef uint32_t AddrType; 375 // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later. 376 typedef uint32_t RefAddrType; 377 TestAllForms<3, AddrType, RefAddrType>(); 378 } 379 380 TEST(DWARFDebugInfo, TestDWARF32Version3Addr8AllForms) { 381 // Test that we can decode all forms for DWARF32, version 3, with 8 byte 382 // addresses. 383 typedef uint64_t AddrType; 384 // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later 385 typedef uint32_t RefAddrType; 386 TestAllForms<3, AddrType, RefAddrType>(); 387 } 388 389 TEST(DWARFDebugInfo, TestDWARF32Version4Addr4AllForms) { 390 // Test that we can decode all forms for DWARF32, version 4, with 4 byte 391 // addresses. 392 typedef uint32_t AddrType; 393 // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later 394 typedef uint32_t RefAddrType; 395 TestAllForms<4, AddrType, RefAddrType>(); 396 } 397 398 TEST(DWARFDebugInfo, TestDWARF32Version4Addr8AllForms) { 399 // Test that we can decode all forms for DWARF32, version 4, with 8 byte 400 // addresses. 401 typedef uint64_t AddrType; 402 // DW_FORM_ref_addr are 4 bytes in DWARF32 for version 3 and later 403 typedef uint32_t RefAddrType; 404 TestAllForms<4, AddrType, RefAddrType>(); 405 } 406 407 template <uint16_t Version, class AddrType> void TestChildren() { 408 // Test that we can decode DW_FORM_ref_addr values correctly in DWARF 2 with 409 // 4 byte addresses. DW_FORM_ref_addr values should be 4 bytes when using 410 // 8 byte addresses. 411 412 const uint8_t AddrSize = sizeof(AddrType); 413 initLLVMIfNeeded(); 414 Triple Triple = getHostTripleForAddrSize(AddrSize); 415 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version); 416 if (HandleExpectedError(ExpectedDG)) 417 return; 418 dwarfgen::Generator *DG = ExpectedDG.get().get(); 419 dwarfgen::CompileUnit &CU = DG->addCompileUnit(); 420 dwarfgen::DIE CUDie = CU.getUnitDIE(); 421 422 CUDie.addAttribute(DW_AT_name, DW_FORM_strp, "/tmp/main.c"); 423 CUDie.addAttribute(DW_AT_language, DW_FORM_data2, DW_LANG_C); 424 425 dwarfgen::DIE SubprogramDie = CUDie.addChild(DW_TAG_subprogram); 426 SubprogramDie.addAttribute(DW_AT_name, DW_FORM_strp, "main"); 427 SubprogramDie.addAttribute(DW_AT_low_pc, DW_FORM_addr, 0x1000U); 428 SubprogramDie.addAttribute(DW_AT_high_pc, DW_FORM_addr, 0x2000U); 429 430 dwarfgen::DIE IntDie = CUDie.addChild(DW_TAG_base_type); 431 IntDie.addAttribute(DW_AT_name, DW_FORM_strp, "int"); 432 IntDie.addAttribute(DW_AT_encoding, DW_FORM_data1, DW_ATE_signed); 433 IntDie.addAttribute(DW_AT_byte_size, DW_FORM_data1, 4); 434 435 dwarfgen::DIE ArgcDie = SubprogramDie.addChild(DW_TAG_formal_parameter); 436 ArgcDie.addAttribute(DW_AT_name, DW_FORM_strp, "argc"); 437 // ArgcDie.addAttribute(DW_AT_type, DW_FORM_ref4, IntDie); 438 ArgcDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, IntDie); 439 440 StringRef FileBytes = DG->generate(); 441 MemoryBufferRef FileBuffer(FileBytes, "dwarf"); 442 auto Obj = object::ObjectFile::createObjectFile(FileBuffer); 443 EXPECT_TRUE((bool)Obj); 444 DWARFContextInMemory DwarfContext(*Obj.get()); 445 446 // Verify the number of compile units is correct. 447 uint32_t NumCUs = DwarfContext.getNumCompileUnits(); 448 EXPECT_EQ(NumCUs, 1u); 449 DWARFCompileUnit *U = DwarfContext.getCompileUnitAtIndex(0); 450 451 // Get the compile unit DIE is valid. 452 auto DiePtr = U->getUnitDIE(false); 453 EXPECT_TRUE(DiePtr != nullptr); 454 // DiePtr->dump(llvm::outs(), U, UINT32_MAX); 455 456 // Verify the first child of the compile unit DIE is our subprogram. 457 auto SubprogramDiePtr = DiePtr->getFirstChild(); 458 EXPECT_TRUE(SubprogramDiePtr != nullptr); 459 EXPECT_EQ(SubprogramDiePtr->getTag(), DW_TAG_subprogram); 460 461 // Verify the first child of the subprogram is our formal parameter. 462 auto ArgcDiePtr = SubprogramDiePtr->getFirstChild(); 463 EXPECT_TRUE(ArgcDiePtr != nullptr); 464 EXPECT_EQ(ArgcDiePtr->getTag(), DW_TAG_formal_parameter); 465 466 // Verify our formal parameter has a NULL tag sibling. 467 auto NullDiePtr = ArgcDiePtr->getSibling(); 468 EXPECT_TRUE(NullDiePtr != nullptr); 469 if (NullDiePtr) { 470 EXPECT_EQ(NullDiePtr->getTag(), DW_TAG_null); 471 EXPECT_TRUE(NullDiePtr->getSibling() == nullptr); 472 EXPECT_TRUE(NullDiePtr->getFirstChild() == nullptr); 473 } 474 475 // Verify the sibling of our subprogram is our integer base type. 476 auto IntDiePtr = SubprogramDiePtr->getSibling(); 477 EXPECT_TRUE(IntDiePtr != nullptr); 478 EXPECT_EQ(IntDiePtr->getTag(), DW_TAG_base_type); 479 480 // Verify the sibling of our subprogram is our integer base is a NULL tag. 481 NullDiePtr = IntDiePtr->getSibling(); 482 EXPECT_TRUE(NullDiePtr != nullptr); 483 if (NullDiePtr) { 484 EXPECT_EQ(NullDiePtr->getTag(), DW_TAG_null); 485 EXPECT_TRUE(NullDiePtr->getSibling() == nullptr); 486 EXPECT_TRUE(NullDiePtr->getFirstChild() == nullptr); 487 } 488 } 489 490 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4Children) { 491 // Test that we can decode all forms for DWARF32, version 2, with 4 byte 492 // addresses. 493 typedef uint32_t AddrType; 494 TestChildren<2, AddrType>(); 495 } 496 497 TEST(DWARFDebugInfo, TestDWARF32Version2Addr8Children) { 498 // Test that we can decode all forms for DWARF32, version 2, with 8 byte 499 // addresses. 500 typedef uint64_t AddrType; 501 TestChildren<2, AddrType>(); 502 } 503 504 TEST(DWARFDebugInfo, TestDWARF32Version3Addr4Children) { 505 // Test that we can decode all forms for DWARF32, version 3, with 4 byte 506 // addresses. 507 typedef uint32_t AddrType; 508 TestChildren<3, AddrType>(); 509 } 510 511 TEST(DWARFDebugInfo, TestDWARF32Version3Addr8Children) { 512 // Test that we can decode all forms for DWARF32, version 3, with 8 byte 513 // addresses. 514 typedef uint64_t AddrType; 515 TestChildren<3, AddrType>(); 516 } 517 518 TEST(DWARFDebugInfo, TestDWARF32Version4Addr4Children) { 519 // Test that we can decode all forms for DWARF32, version 4, with 4 byte 520 // addresses. 521 typedef uint32_t AddrType; 522 TestChildren<4, AddrType>(); 523 } 524 525 TEST(DWARFDebugInfo, TestDWARF32Version4Addr8Children) { 526 // Test that we can decode all forms for DWARF32, version 4, with 8 byte 527 // addresses. 528 typedef uint64_t AddrType; 529 TestChildren<4, AddrType>(); 530 } 531 532 template <uint16_t Version, class AddrType> void TestReferences() { 533 // Test that we can decode DW_FORM_refXXX values correctly in DWARF. 534 535 const uint8_t AddrSize = sizeof(AddrType); 536 initLLVMIfNeeded(); 537 Triple Triple = getHostTripleForAddrSize(AddrSize); 538 auto ExpectedDG = dwarfgen::Generator::create(Triple, Version); 539 if (HandleExpectedError(ExpectedDG)) 540 return; 541 dwarfgen::Generator *DG = ExpectedDG.get().get(); 542 dwarfgen::CompileUnit &CU1 = DG->addCompileUnit(); 543 dwarfgen::CompileUnit &CU2 = DG->addCompileUnit(); 544 545 dwarfgen::DIE CU1Die = CU1.getUnitDIE(); 546 CU1Die.addAttribute(DW_AT_name, DW_FORM_strp, "/tmp/main.c"); 547 CU1Die.addAttribute(DW_AT_language, DW_FORM_data2, DW_LANG_C); 548 549 dwarfgen::DIE CU1TypeDie = CU1Die.addChild(DW_TAG_base_type); 550 CU1TypeDie.addAttribute(DW_AT_name, DW_FORM_strp, "int"); 551 CU1TypeDie.addAttribute(DW_AT_encoding, DW_FORM_data1, DW_ATE_signed); 552 CU1TypeDie.addAttribute(DW_AT_byte_size, DW_FORM_data1, 4); 553 554 dwarfgen::DIE CU1Ref1Die = CU1Die.addChild(DW_TAG_variable); 555 CU1Ref1Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU1Ref1"); 556 CU1Ref1Die.addAttribute(DW_AT_type, DW_FORM_ref1, CU1TypeDie); 557 558 dwarfgen::DIE CU1Ref2Die = CU1Die.addChild(DW_TAG_variable); 559 CU1Ref2Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU1Ref2"); 560 CU1Ref2Die.addAttribute(DW_AT_type, DW_FORM_ref2, CU1TypeDie); 561 562 dwarfgen::DIE CU1Ref4Die = CU1Die.addChild(DW_TAG_variable); 563 CU1Ref4Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU1Ref4"); 564 CU1Ref4Die.addAttribute(DW_AT_type, DW_FORM_ref4, CU1TypeDie); 565 566 dwarfgen::DIE CU1Ref8Die = CU1Die.addChild(DW_TAG_variable); 567 CU1Ref8Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU1Ref8"); 568 CU1Ref8Die.addAttribute(DW_AT_type, DW_FORM_ref8, CU1TypeDie); 569 570 dwarfgen::DIE CU1RefAddrDie = CU1Die.addChild(DW_TAG_variable); 571 CU1RefAddrDie.addAttribute(DW_AT_name, DW_FORM_strp, "CU1RefAddr"); 572 CU1RefAddrDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, CU1TypeDie); 573 574 dwarfgen::DIE CU2Die = CU2.getUnitDIE(); 575 CU2Die.addAttribute(DW_AT_name, DW_FORM_strp, "/tmp/foo.c"); 576 CU2Die.addAttribute(DW_AT_language, DW_FORM_data2, DW_LANG_C); 577 578 dwarfgen::DIE CU2TypeDie = CU2Die.addChild(DW_TAG_base_type); 579 CU2TypeDie.addAttribute(DW_AT_name, DW_FORM_strp, "float"); 580 CU2TypeDie.addAttribute(DW_AT_encoding, DW_FORM_data1, DW_ATE_float); 581 CU2TypeDie.addAttribute(DW_AT_byte_size, DW_FORM_data1, 4); 582 583 dwarfgen::DIE CU2Ref1Die = CU2Die.addChild(DW_TAG_variable); 584 CU2Ref1Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU2Ref1"); 585 CU2Ref1Die.addAttribute(DW_AT_type, DW_FORM_ref1, CU2TypeDie); 586 587 dwarfgen::DIE CU2Ref2Die = CU2Die.addChild(DW_TAG_variable); 588 CU2Ref2Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU2Ref2"); 589 CU2Ref2Die.addAttribute(DW_AT_type, DW_FORM_ref2, CU2TypeDie); 590 591 dwarfgen::DIE CU2Ref4Die = CU2Die.addChild(DW_TAG_variable); 592 CU2Ref4Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU2Ref4"); 593 CU2Ref4Die.addAttribute(DW_AT_type, DW_FORM_ref4, CU2TypeDie); 594 595 dwarfgen::DIE CU2Ref8Die = CU2Die.addChild(DW_TAG_variable); 596 CU2Ref8Die.addAttribute(DW_AT_name, DW_FORM_strp, "CU2Ref8"); 597 CU2Ref8Die.addAttribute(DW_AT_type, DW_FORM_ref8, CU2TypeDie); 598 599 dwarfgen::DIE CU2RefAddrDie = CU2Die.addChild(DW_TAG_variable); 600 CU2RefAddrDie.addAttribute(DW_AT_name, DW_FORM_strp, "CU2RefAddr"); 601 CU2RefAddrDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, CU2TypeDie); 602 603 // Refer to a type in CU1 from CU2 604 dwarfgen::DIE CU2ToCU1RefAddrDie = CU2Die.addChild(DW_TAG_variable); 605 CU2ToCU1RefAddrDie.addAttribute(DW_AT_name, DW_FORM_strp, "CU2ToCU1RefAddr"); 606 CU2ToCU1RefAddrDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, CU1TypeDie); 607 608 // Refer to a type in CU2 from CU1 609 dwarfgen::DIE CU1ToCU2RefAddrDie = CU1Die.addChild(DW_TAG_variable); 610 CU1ToCU2RefAddrDie.addAttribute(DW_AT_name, DW_FORM_strp, "CU1ToCU2RefAddr"); 611 CU1ToCU2RefAddrDie.addAttribute(DW_AT_type, DW_FORM_ref_addr, CU2TypeDie); 612 613 StringRef FileBytes = DG->generate(); 614 MemoryBufferRef FileBuffer(FileBytes, "dwarf"); 615 auto Obj = object::ObjectFile::createObjectFile(FileBuffer); 616 EXPECT_TRUE((bool)Obj); 617 DWARFContextInMemory DwarfContext(*Obj.get()); 618 619 // Verify the number of compile units is correct. 620 uint32_t NumCUs = DwarfContext.getNumCompileUnits(); 621 EXPECT_EQ(NumCUs, 2u); 622 DWARFCompileUnit *U1 = DwarfContext.getCompileUnitAtIndex(0); 623 DWARFCompileUnit *U2 = DwarfContext.getCompileUnitAtIndex(1); 624 625 // Get the compile unit DIE is valid. 626 auto Unit1DiePtr = U1->getUnitDIE(false); 627 EXPECT_TRUE(Unit1DiePtr != nullptr); 628 // Unit1DiePtr->dump(llvm::outs(), U1, UINT32_MAX); 629 630 auto Unit2DiePtr = U2->getUnitDIE(false); 631 EXPECT_TRUE(Unit2DiePtr != nullptr); 632 // Unit2DiePtr->dump(llvm::outs(), U2, UINT32_MAX); 633 634 // Verify the first child of the compile unit 1 DIE is our int base type. 635 auto CU1TypeDiePtr = Unit1DiePtr->getFirstChild(); 636 EXPECT_TRUE(CU1TypeDiePtr != nullptr); 637 EXPECT_EQ(CU1TypeDiePtr->getTag(), DW_TAG_base_type); 638 EXPECT_EQ( 639 CU1TypeDiePtr->getAttributeValueAsUnsignedConstant(U1, DW_AT_encoding, 0), 640 DW_ATE_signed); 641 642 // Verify the first child of the compile unit 2 DIE is our float base type. 643 auto CU2TypeDiePtr = Unit2DiePtr->getFirstChild(); 644 EXPECT_TRUE(CU2TypeDiePtr != nullptr); 645 EXPECT_EQ(CU2TypeDiePtr->getTag(), DW_TAG_base_type); 646 EXPECT_EQ( 647 CU2TypeDiePtr->getAttributeValueAsUnsignedConstant(U2, DW_AT_encoding, 0), 648 DW_ATE_float); 649 650 // Verify the sibling of the base type DIE is our Ref1 DIE and that its 651 // DW_AT_type points to our base type DIE. 652 auto CU1Ref1DiePtr = CU1TypeDiePtr->getSibling(); 653 EXPECT_TRUE(CU1Ref1DiePtr != nullptr); 654 EXPECT_EQ(CU1Ref1DiePtr->getTag(), DW_TAG_variable); 655 EXPECT_EQ(CU1Ref1DiePtr->getAttributeValueAsReference(U1, DW_AT_type, -1ULL), 656 CU1TypeDiePtr->getOffset()); 657 // Verify the sibling is our Ref2 DIE and that its DW_AT_type points to our 658 // base type DIE in CU1. 659 auto CU1Ref2DiePtr = CU1Ref1DiePtr->getSibling(); 660 EXPECT_TRUE(CU1Ref2DiePtr != nullptr); 661 EXPECT_EQ(CU1Ref2DiePtr->getTag(), DW_TAG_variable); 662 EXPECT_EQ(CU1Ref2DiePtr->getAttributeValueAsReference(U1, DW_AT_type, -1ULL), 663 CU1TypeDiePtr->getOffset()); 664 665 // Verify the sibling is our Ref4 DIE and that its DW_AT_type points to our 666 // base type DIE in CU1. 667 auto CU1Ref4DiePtr = CU1Ref2DiePtr->getSibling(); 668 EXPECT_TRUE(CU1Ref4DiePtr != nullptr); 669 EXPECT_EQ(CU1Ref4DiePtr->getTag(), DW_TAG_variable); 670 EXPECT_EQ(CU1Ref4DiePtr->getAttributeValueAsReference(U1, DW_AT_type, -1ULL), 671 CU1TypeDiePtr->getOffset()); 672 673 // Verify the sibling is our Ref8 DIE and that its DW_AT_type points to our 674 // base type DIE in CU1. 675 auto CU1Ref8DiePtr = CU1Ref4DiePtr->getSibling(); 676 EXPECT_TRUE(CU1Ref8DiePtr != nullptr); 677 EXPECT_EQ(CU1Ref8DiePtr->getTag(), DW_TAG_variable); 678 EXPECT_EQ(CU1Ref8DiePtr->getAttributeValueAsReference(U1, DW_AT_type, -1ULL), 679 CU1TypeDiePtr->getOffset()); 680 681 // Verify the sibling is our RefAddr DIE and that its DW_AT_type points to our 682 // base type DIE in CU1. 683 auto CU1RefAddrDiePtr = CU1Ref8DiePtr->getSibling(); 684 EXPECT_TRUE(CU1RefAddrDiePtr != nullptr); 685 EXPECT_EQ(CU1RefAddrDiePtr->getTag(), DW_TAG_variable); 686 EXPECT_EQ( 687 CU1RefAddrDiePtr->getAttributeValueAsReference(U1, DW_AT_type, -1ULL), 688 CU1TypeDiePtr->getOffset()); 689 690 // Verify the sibling of the Ref4 DIE is our RefAddr DIE and that its 691 // DW_AT_type points to our base type DIE. 692 auto CU1ToCU2RefAddrDiePtr = CU1RefAddrDiePtr->getSibling(); 693 EXPECT_TRUE(CU1ToCU2RefAddrDiePtr != nullptr); 694 EXPECT_EQ(CU1ToCU2RefAddrDiePtr->getTag(), DW_TAG_variable); 695 EXPECT_EQ(CU1ToCU2RefAddrDiePtr->getAttributeValueAsReference(U1, DW_AT_type, 696 -1ULL), 697 CU2TypeDiePtr->getOffset()); 698 699 // Verify the sibling of the base type DIE is our Ref1 DIE and that its 700 // DW_AT_type points to our base type DIE. 701 auto CU2Ref1DiePtr = CU2TypeDiePtr->getSibling(); 702 EXPECT_TRUE(CU2Ref1DiePtr != nullptr); 703 EXPECT_EQ(CU2Ref1DiePtr->getTag(), DW_TAG_variable); 704 EXPECT_EQ(CU2Ref1DiePtr->getAttributeValueAsReference(U2, DW_AT_type, -1ULL), 705 CU2TypeDiePtr->getOffset()); 706 // Verify the sibling is our Ref2 DIE and that its DW_AT_type points to our 707 // base type DIE in CU2. 708 auto CU2Ref2DiePtr = CU2Ref1DiePtr->getSibling(); 709 EXPECT_TRUE(CU2Ref2DiePtr != nullptr); 710 EXPECT_EQ(CU2Ref2DiePtr->getTag(), DW_TAG_variable); 711 EXPECT_EQ(CU2Ref2DiePtr->getAttributeValueAsReference(U2, DW_AT_type, -1ULL), 712 CU2TypeDiePtr->getOffset()); 713 714 // Verify the sibling is our Ref4 DIE and that its DW_AT_type points to our 715 // base type DIE in CU2. 716 auto CU2Ref4DiePtr = CU2Ref2DiePtr->getSibling(); 717 EXPECT_TRUE(CU2Ref4DiePtr != nullptr); 718 EXPECT_EQ(CU2Ref4DiePtr->getTag(), DW_TAG_variable); 719 EXPECT_EQ(CU2Ref4DiePtr->getAttributeValueAsReference(U2, DW_AT_type, -1ULL), 720 CU2TypeDiePtr->getOffset()); 721 722 // Verify the sibling is our Ref8 DIE and that its DW_AT_type points to our 723 // base type DIE in CU2. 724 auto CU2Ref8DiePtr = CU2Ref4DiePtr->getSibling(); 725 EXPECT_TRUE(CU2Ref8DiePtr != nullptr); 726 EXPECT_EQ(CU2Ref8DiePtr->getTag(), DW_TAG_variable); 727 EXPECT_EQ(CU2Ref8DiePtr->getAttributeValueAsReference(U2, DW_AT_type, -1ULL), 728 CU2TypeDiePtr->getOffset()); 729 730 // Verify the sibling is our RefAddr DIE and that its DW_AT_type points to our 731 // base type DIE in CU2. 732 auto CU2RefAddrDiePtr = CU2Ref8DiePtr->getSibling(); 733 EXPECT_TRUE(CU2RefAddrDiePtr != nullptr); 734 EXPECT_EQ(CU2RefAddrDiePtr->getTag(), DW_TAG_variable); 735 EXPECT_EQ( 736 CU2RefAddrDiePtr->getAttributeValueAsReference(U2, DW_AT_type, -1ULL), 737 CU2TypeDiePtr->getOffset()); 738 739 // Verify the sibling of the Ref4 DIE is our RefAddr DIE and that its 740 // DW_AT_type points to our base type DIE. 741 auto CU2ToCU1RefAddrDiePtr = CU2RefAddrDiePtr->getSibling(); 742 EXPECT_TRUE(CU2ToCU1RefAddrDiePtr != nullptr); 743 EXPECT_EQ(CU2ToCU1RefAddrDiePtr->getTag(), DW_TAG_variable); 744 EXPECT_EQ(CU2ToCU1RefAddrDiePtr->getAttributeValueAsReference(U2, DW_AT_type, 745 -1ULL), 746 CU1TypeDiePtr->getOffset()); 747 } 748 749 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4References) { 750 // Test that we can decode all forms for DWARF32, version 2, with 4 byte 751 // addresses. 752 typedef uint32_t AddrType; 753 TestReferences<2, AddrType>(); 754 } 755 756 TEST(DWARFDebugInfo, TestDWARF32Version2Addr8References) { 757 // Test that we can decode all forms for DWARF32, version 2, with 8 byte 758 // addresses. 759 typedef uint64_t AddrType; 760 TestReferences<2, AddrType>(); 761 } 762 763 TEST(DWARFDebugInfo, TestDWARF32Version3Addr4References) { 764 // Test that we can decode all forms for DWARF32, version 3, with 4 byte 765 // addresses. 766 typedef uint32_t AddrType; 767 TestReferences<3, AddrType>(); 768 } 769 770 TEST(DWARFDebugInfo, TestDWARF32Version3Addr8References) { 771 // Test that we can decode all forms for DWARF32, version 3, with 8 byte 772 // addresses. 773 typedef uint64_t AddrType; 774 TestReferences<3, AddrType>(); 775 } 776 777 TEST(DWARFDebugInfo, TestDWARF32Version4Addr4References) { 778 // Test that we can decode all forms for DWARF32, version 4, with 4 byte 779 // addresses. 780 typedef uint32_t AddrType; 781 TestReferences<4, AddrType>(); 782 } 783 784 TEST(DWARFDebugInfo, TestDWARF32Version4Addr8References) { 785 // Test that we can decode all forms for DWARF32, version 4, with 8 byte 786 // addresses. 787 typedef uint64_t AddrType; 788 TestReferences<4, AddrType>(); 789 } 790 791 } // end anonymous namespace 792