1 // dwarf_reader.h -- parse dwarf2/3 debug information for gold -*- C++ -*- 2 3 // Copyright (C) 2007-2020 Free Software Foundation, Inc. 4 // Written by Ian Lance Taylor <iant@google.com>. 5 6 // This file is part of gold. 7 8 // This program is free software; you can redistribute it and/or modify 9 // it under the terms of the GNU General Public License as published by 10 // the Free Software Foundation; either version 3 of the License, or 11 // (at your option) any later version. 12 13 // This program is distributed in the hope that it will be useful, 14 // but WITHOUT ANY WARRANTY; without even the implied warranty of 15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 // GNU General Public License for more details. 17 18 // You should have received a copy of the GNU General Public License 19 // along with this program; if not, write to the Free Software 20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21 // MA 02110-1301, USA. 22 23 #ifndef GOLD_DWARF_READER_H 24 #define GOLD_DWARF_READER_H 25 26 #include <vector> 27 #include <map> 28 #include <limits.h> 29 #include <sys/types.h> 30 31 #include "elfcpp.h" 32 #include "elfcpp_swap.h" 33 #include "dwarf.h" 34 #include "reloc.h" 35 36 namespace gold 37 { 38 39 class Dwarf_info_reader; 40 struct LineStateMachine; 41 42 // This class is used to extract the section index and offset of 43 // the target of a relocation for a given offset within the section. 44 45 class Elf_reloc_mapper 46 { 47 public: 48 Elf_reloc_mapper() 49 { } 50 51 virtual 52 ~Elf_reloc_mapper() 53 { } 54 55 // Initialize the relocation tracker for section RELOC_SHNDX. 56 bool 57 initialize(unsigned int reloc_shndx, unsigned int reloc_type) 58 { return this->do_initialize(reloc_shndx, reloc_type); } 59 60 // Return the next reloc_offset. 61 off_t 62 next_offset() 63 { return this->do_next_offset(); } 64 65 // Advance to the next relocation past OFFSET. 66 void 67 advance(off_t offset) 68 { this->do_advance(offset); } 69 70 // Return the section index and offset within the section of the target 71 // of the relocation for RELOC_OFFSET in the referring section. 72 unsigned int 73 get_reloc_target(off_t reloc_offset, off_t* target_offset) 74 { return this->do_get_reloc_target(reloc_offset, target_offset); } 75 76 // Checkpoint the current position in the reloc section. 77 uint64_t 78 checkpoint() const 79 { return this->do_checkpoint(); } 80 81 // Reset the current position to the CHECKPOINT. 82 void 83 reset(uint64_t checkpoint) 84 { this->do_reset(checkpoint); } 85 86 protected: 87 virtual bool 88 do_initialize(unsigned int, unsigned int) = 0; 89 90 // Return the next reloc_offset. 91 virtual off_t 92 do_next_offset() = 0; 93 94 // Advance to the next relocation past OFFSET. 95 virtual void 96 do_advance(off_t offset) = 0; 97 98 virtual unsigned int 99 do_get_reloc_target(off_t reloc_offset, off_t* target_offset) = 0; 100 101 // Checkpoint the current position in the reloc section. 102 virtual uint64_t 103 do_checkpoint() const = 0; 104 105 // Reset the current position to the CHECKPOINT. 106 virtual void 107 do_reset(uint64_t checkpoint) = 0; 108 }; 109 110 template<int size, bool big_endian> 111 class Sized_elf_reloc_mapper : public Elf_reloc_mapper 112 { 113 public: 114 Sized_elf_reloc_mapper(Object* object, const unsigned char* symtab, 115 off_t symtab_size) 116 : object_(object), symtab_(symtab), symtab_size_(symtab_size), 117 reloc_type_(0), track_relocs_() 118 { } 119 120 protected: 121 bool 122 do_initialize(unsigned int reloc_shndx, unsigned int reloc_type); 123 124 // Return the next reloc_offset. 125 virtual off_t 126 do_next_offset() 127 { return this->track_relocs_.next_offset(); } 128 129 // Advance to the next relocation past OFFSET. 130 virtual void 131 do_advance(off_t offset) 132 { this->track_relocs_.advance(offset); } 133 134 unsigned int 135 do_get_reloc_target(off_t reloc_offset, off_t* target_offset); 136 137 // Checkpoint the current position in the reloc section. 138 uint64_t 139 do_checkpoint() const 140 { return this->track_relocs_.checkpoint(); } 141 142 // Reset the current position to the CHECKPOINT. 143 void 144 do_reset(uint64_t checkpoint) 145 { this->track_relocs_.reset(checkpoint); } 146 147 private: 148 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; 149 150 // Return the section index of symbol SYMNDX, and copy its value to *VALUE. 151 // Set *IS_ORDINARY true if the section index is an ordinary section index. 152 unsigned int 153 symbol_section(unsigned int symndx, Address* value, bool* is_ordinary); 154 155 // The object file. 156 Object* object_; 157 // The ELF symbol table. 158 const unsigned char* symtab_; 159 // The size of the ELF symbol table. 160 off_t symtab_size_; 161 // Type of the relocation section (SHT_REL or SHT_RELA). 162 unsigned int reloc_type_; 163 // Relocations for the referring section. 164 Track_relocs<size, big_endian> track_relocs_; 165 }; 166 167 // This class is used to read the abbreviations table from the 168 // .debug_abbrev section of the object file. 169 170 class Dwarf_abbrev_table 171 { 172 public: 173 // An attribute list entry. 174 struct Attribute 175 { 176 Attribute(unsigned int a, unsigned int f) 177 : attr(a), form(f) 178 { } 179 unsigned int attr; 180 unsigned int form; 181 }; 182 183 // An abbrev code entry. 184 struct Abbrev_code 185 { 186 Abbrev_code(unsigned int t, bool hc) 187 : tag(t), has_children(hc), has_sibling_attribute(false), attributes() 188 { 189 this->attributes.reserve(10); 190 } 191 192 void 193 add_attribute(unsigned int attr, unsigned int form) 194 { 195 this->attributes.push_back(Attribute(attr, form)); 196 } 197 198 // The DWARF tag. 199 unsigned int tag; 200 // True if the DIE has children. 201 bool has_children : 1; 202 // True if the DIE has a sibling attribute. 203 bool has_sibling_attribute : 1; 204 // The list of attributes and forms. 205 std::vector<Attribute> attributes; 206 }; 207 208 Dwarf_abbrev_table() 209 : abbrev_shndx_(0), abbrev_offset_(0), buffer_(NULL), buffer_end_(NULL), 210 owns_buffer_(false), buffer_pos_(NULL), high_abbrev_codes_() 211 { 212 memset(this->low_abbrev_codes_, 0, sizeof(this->low_abbrev_codes_)); 213 } 214 215 ~Dwarf_abbrev_table() 216 { 217 if (this->owns_buffer_ && this->buffer_ != NULL) 218 delete[] this->buffer_; 219 this->clear_abbrev_codes(); 220 } 221 222 // Read the abbrev table from an object file. 223 bool 224 read_abbrevs(Relobj* object, 225 unsigned int abbrev_shndx, 226 off_t abbrev_offset) 227 { 228 // If we've already read this abbrev table, return immediately. 229 if (this->abbrev_shndx_ > 0 230 && this->abbrev_shndx_ == abbrev_shndx 231 && this->abbrev_offset_ == abbrev_offset) 232 return true; 233 return this->do_read_abbrevs(object, abbrev_shndx, abbrev_offset); 234 } 235 236 // Return the abbrev code entry for CODE. This is a fast path for 237 // abbrev codes that are in the direct lookup table. If not found 238 // there, we call do_get_abbrev() to do the hard work. 239 const Abbrev_code* 240 get_abbrev(unsigned int code) 241 { 242 if (code < this->low_abbrev_code_max_ 243 && this->low_abbrev_codes_[code] != NULL) 244 return this->low_abbrev_codes_[code]; 245 return this->do_get_abbrev(code); 246 } 247 248 private: 249 // Read the abbrev table from an object file. 250 bool 251 do_read_abbrevs(Relobj* object, 252 unsigned int abbrev_shndx, 253 off_t abbrev_offset); 254 255 // Lookup the abbrev code entry for CODE. 256 const Abbrev_code* 257 do_get_abbrev(unsigned int code); 258 259 // Store an abbrev code entry for CODE. 260 void 261 store_abbrev(unsigned int code, const Abbrev_code* entry) 262 { 263 if (code < this->low_abbrev_code_max_) 264 this->low_abbrev_codes_[code] = entry; 265 else 266 this->high_abbrev_codes_[code] = entry; 267 } 268 269 // Clear the abbrev code table and release the memory it uses. 270 void 271 clear_abbrev_codes(); 272 273 typedef Unordered_map<unsigned int, const Abbrev_code*> Abbrev_code_table; 274 275 // The section index of the current abbrev table. 276 unsigned int abbrev_shndx_; 277 // The offset within the section of the current abbrev table. 278 off_t abbrev_offset_; 279 // The buffer containing the .debug_abbrev section. 280 const unsigned char* buffer_; 281 const unsigned char* buffer_end_; 282 // True if this object owns the buffer and needs to delete it. 283 bool owns_buffer_; 284 // Pointer to the current position in the buffer. 285 const unsigned char* buffer_pos_; 286 // The table of abbrev codes. 287 // We use a direct-lookup array for low abbrev codes, 288 // and store the rest in a hash table. 289 static const unsigned int low_abbrev_code_max_ = 256; 290 const Abbrev_code* low_abbrev_codes_[low_abbrev_code_max_]; 291 Abbrev_code_table high_abbrev_codes_; 292 }; 293 294 // A DWARF range list. The start and end offsets are relative 295 // to the input section SHNDX. Each range must lie entirely 296 // within a single section. 297 298 class Dwarf_range_list 299 { 300 public: 301 struct Range 302 { 303 Range(unsigned int a_shndx, off_t a_start, off_t a_end) 304 : shndx(a_shndx), start(a_start), end(a_end) 305 { } 306 307 unsigned int shndx; 308 off_t start; 309 off_t end; 310 }; 311 312 Dwarf_range_list() 313 : range_list_() 314 { } 315 316 void 317 add(unsigned int shndx, off_t start, off_t end) 318 { this->range_list_.push_back(Range(shndx, start, end)); } 319 320 size_t 321 size() const 322 { return this->range_list_.size(); } 323 324 const Range& 325 operator[](off_t i) const 326 { return this->range_list_[i]; } 327 328 private: 329 std::vector<Range> range_list_; 330 }; 331 332 // This class is used to read the ranges table from the 333 // .debug_ranges section of the object file. 334 335 class Dwarf_ranges_table 336 { 337 public: 338 Dwarf_ranges_table(Dwarf_info_reader* dwinfo) 339 : dwinfo_(dwinfo), ranges_shndx_(0), ranges_buffer_(NULL), 340 ranges_buffer_end_(NULL), owns_ranges_buffer_(false), 341 ranges_reloc_mapper_(NULL), reloc_type_(0), output_section_offset_(0) 342 { } 343 344 ~Dwarf_ranges_table() 345 { 346 if (this->owns_ranges_buffer_ && this->ranges_buffer_ != NULL) 347 delete[] this->ranges_buffer_; 348 if (this->ranges_reloc_mapper_ != NULL) 349 delete this->ranges_reloc_mapper_; 350 } 351 352 // Read the ranges table from an object file. 353 bool 354 read_ranges_table(Relobj* object, 355 const unsigned char* symtab, 356 off_t symtab_size, 357 unsigned int ranges_shndx); 358 359 // Read the range table from an object file. 360 Dwarf_range_list* 361 read_range_list(Relobj* object, 362 const unsigned char* symtab, 363 off_t symtab_size, 364 unsigned int address_size, 365 unsigned int ranges_shndx, 366 off_t ranges_offset); 367 368 // Look for a relocation at offset OFF in the range table, 369 // and return the section index and offset of the target. 370 unsigned int 371 lookup_reloc(off_t off, off_t* target_off); 372 373 private: 374 // The Dwarf_info_reader, for reading data. 375 Dwarf_info_reader* dwinfo_; 376 // The section index of the ranges table. 377 unsigned int ranges_shndx_; 378 // The buffer containing the .debug_ranges section. 379 const unsigned char* ranges_buffer_; 380 const unsigned char* ranges_buffer_end_; 381 // True if this object owns the buffer and needs to delete it. 382 bool owns_ranges_buffer_; 383 // Relocation mapper for the .debug_ranges section. 384 Elf_reloc_mapper* ranges_reloc_mapper_; 385 // Type of the relocation section (SHT_REL or SHT_RELA). 386 unsigned int reloc_type_; 387 // For incremental update links, this will hold the offset of the 388 // input section within the output section. Offsets read from 389 // relocated data will be relative to the output section, and need 390 // to be corrected before reading data from the input section. 391 uint64_t output_section_offset_; 392 }; 393 394 // This class is used to read the pubnames and pubtypes tables from the 395 // .debug_pubnames and .debug_pubtypes sections of the object file. 396 397 class Dwarf_pubnames_table 398 { 399 public: 400 Dwarf_pubnames_table(Dwarf_info_reader* dwinfo, bool is_pubtypes) 401 : dwinfo_(dwinfo), buffer_(NULL), buffer_end_(NULL), owns_buffer_(false), 402 offset_size_(0), pinfo_(NULL), end_of_table_(NULL), 403 is_pubtypes_(is_pubtypes), is_gnu_style_(false), 404 unit_length_(0), cu_offset_(0) 405 { } 406 407 ~Dwarf_pubnames_table() 408 { 409 if (this->owns_buffer_ && this->buffer_ != NULL) 410 delete[] this->buffer_; 411 } 412 413 // Read the pubnames section from the object file, using the symbol 414 // table for relocating it. 415 bool 416 read_section(Relobj* object, const unsigned char* symbol_table, 417 off_t symtab_size); 418 419 // Read the header for the set at OFFSET. 420 bool 421 read_header(off_t offset); 422 423 // Return the offset to the cu within the info or types section. 424 off_t 425 cu_offset() 426 { return this->cu_offset_; } 427 428 // Return the size of this subsection of the table. The unit length 429 // doesn't include the size of its own field. 430 off_t 431 subsection_size() 432 { return this->unit_length_; } 433 434 // Read the next name from the set. If the pubname table is gnu-style, 435 // FLAG_BYTE is set to the high-byte of a gdb_index version 7 cu_index. 436 const char* 437 next_name(uint8_t* flag_byte); 438 439 private: 440 // The Dwarf_info_reader, for reading data. 441 Dwarf_info_reader* dwinfo_; 442 // The buffer containing the .debug_ranges section. 443 const unsigned char* buffer_; 444 const unsigned char* buffer_end_; 445 // True if this object owns the buffer and needs to delete it. 446 bool owns_buffer_; 447 // The size of a DWARF offset for the current set. 448 unsigned int offset_size_; 449 // The current position within the buffer. 450 const unsigned char* pinfo_; 451 // The end of the current pubnames table. 452 const unsigned char* end_of_table_; 453 // TRUE if this is a .debug_pubtypes section. 454 bool is_pubtypes_; 455 // Gnu-style pubnames table. This style has an extra flag byte between the 456 // offset and the name, and is used for generating version 7 of gdb-index. 457 bool is_gnu_style_; 458 // Fields read from the header. 459 uint64_t unit_length_; 460 off_t cu_offset_; 461 462 // Track relocations for this table so we can find the CUs that 463 // correspond to the subsections. 464 Elf_reloc_mapper* reloc_mapper_; 465 // Type of the relocation section (SHT_REL or SHT_RELA). 466 unsigned int reloc_type_; 467 }; 468 469 // This class represents a DWARF Debug Info Entry (DIE). 470 471 class Dwarf_die 472 { 473 public: 474 // An attribute value. 475 struct Attribute_value 476 { 477 unsigned int attr; 478 unsigned int form; 479 union 480 { 481 int64_t intval; 482 uint64_t uintval; 483 const char* stringval; 484 const unsigned char* blockval; 485 off_t refval; 486 } val; 487 union 488 { 489 // Section index for reference forms. 490 unsigned int shndx; 491 // Block length for block forms. 492 unsigned int blocklen; 493 // Attribute offset for DW_FORM_strp. 494 unsigned int attr_off; 495 } aux; 496 }; 497 498 // A list of attribute values. 499 typedef std::vector<Attribute_value> Attributes; 500 501 Dwarf_die(Dwarf_info_reader* dwinfo, 502 off_t die_offset, 503 Dwarf_die* parent); 504 505 // Return the DWARF tag for this DIE. 506 unsigned int 507 tag() const 508 { 509 if (this->abbrev_code_ == NULL) 510 return 0; 511 return this->abbrev_code_->tag; 512 } 513 514 // Return true if this DIE has children. 515 bool 516 has_children() const 517 { 518 gold_assert(this->abbrev_code_ != NULL); 519 return this->abbrev_code_->has_children; 520 } 521 522 // Return true if this DIE has a sibling attribute. 523 bool 524 has_sibling_attribute() const 525 { 526 gold_assert(this->abbrev_code_ != NULL); 527 return this->abbrev_code_->has_sibling_attribute; 528 } 529 530 // Return the value of attribute ATTR. 531 const Attribute_value* 532 attribute(unsigned int attr); 533 534 // Return the value of the DW_AT_name attribute. 535 const char* 536 name() 537 { 538 if (this->name_ == NULL) 539 this->set_name(); 540 return this->name_; 541 } 542 543 // Return the value of the DW_AT_linkage_name 544 // or DW_AT_MIPS_linkage_name attribute. 545 const char* 546 linkage_name() 547 { 548 if (this->linkage_name_ == NULL) 549 this->set_linkage_name(); 550 return this->linkage_name_; 551 } 552 553 // Return the value of the DW_AT_specification attribute. 554 off_t 555 specification() 556 { 557 if (!this->attributes_read_) 558 this->read_attributes(); 559 return this->specification_; 560 } 561 562 // Return the value of the DW_AT_abstract_origin attribute. 563 off_t 564 abstract_origin() 565 { 566 if (!this->attributes_read_) 567 this->read_attributes(); 568 return this->abstract_origin_; 569 } 570 571 // Return the value of attribute ATTR as a string. 572 const char* 573 string_attribute(unsigned int attr); 574 575 // Return the value of attribute ATTR as an integer. 576 int64_t 577 int_attribute(unsigned int attr); 578 579 // Return the value of attribute ATTR as an unsigned integer. 580 uint64_t 581 uint_attribute(unsigned int attr); 582 583 // Return the value of attribute ATTR as a reference. 584 off_t 585 ref_attribute(unsigned int attr, unsigned int* shndx); 586 587 // Return the value of attribute ATTR as a address. 588 off_t 589 address_attribute(unsigned int attr, unsigned int* shndx); 590 591 // Return the value of attribute ATTR as a flag. 592 bool 593 flag_attribute(unsigned int attr) 594 { return this->int_attribute(attr) != 0; } 595 596 // Return true if this DIE is a declaration. 597 bool 598 is_declaration() 599 { return this->flag_attribute(elfcpp::DW_AT_declaration); } 600 601 // Return the parent of this DIE. 602 Dwarf_die* 603 parent() const 604 { return this->parent_; } 605 606 // Return the offset of this DIE. 607 off_t 608 offset() const 609 { return this->die_offset_; } 610 611 // Return the offset of this DIE's first child. 612 off_t 613 child_offset(); 614 615 // Set the offset of this DIE's next sibling. 616 void 617 set_sibling_offset(off_t sibling_offset) 618 { this->sibling_offset_ = sibling_offset; } 619 620 // Return the offset of this DIE's next sibling. 621 off_t 622 sibling_offset(); 623 624 private: 625 typedef Dwarf_abbrev_table::Abbrev_code Abbrev_code; 626 627 // Read all the attributes of the DIE. 628 bool 629 read_attributes(); 630 631 // Set the name of the DIE if present. 632 void 633 set_name(); 634 635 // Set the linkage name if present. 636 void 637 set_linkage_name(); 638 639 // Skip all the attributes of the DIE and return the offset 640 // of the next DIE. 641 off_t 642 skip_attributes(); 643 644 // The Dwarf_info_reader, for reading attributes. 645 Dwarf_info_reader* dwinfo_; 646 // The parent of this DIE. 647 Dwarf_die* parent_; 648 // Offset of this DIE within its compilation unit. 649 off_t die_offset_; 650 // Offset of the first attribute, relative to the beginning of the DIE. 651 off_t attr_offset_; 652 // Offset of the first child, relative to the compilation unit. 653 off_t child_offset_; 654 // Offset of the next sibling, relative to the compilation unit. 655 off_t sibling_offset_; 656 // The abbreviation table entry. 657 const Abbrev_code* abbrev_code_; 658 // The list of attributes. 659 Attributes attributes_; 660 // True if the attributes have been read. 661 bool attributes_read_; 662 // The following fields hold common attributes to avoid a linear 663 // search through the attribute list. 664 // The DIE name (DW_AT_name). 665 const char* name_; 666 // Offset of the name in the string table (for DW_FORM_strp). 667 off_t name_off_; 668 // The linkage name (DW_AT_linkage_name or DW_AT_MIPS_linkage_name). 669 const char* linkage_name_; 670 // Offset of the linkage name in the string table (for DW_FORM_strp). 671 off_t linkage_name_off_; 672 // Section index of the string table (for DW_FORM_strp). 673 unsigned int string_shndx_; 674 // The value of a DW_AT_specification attribute. 675 off_t specification_; 676 // The value of a DW_AT_abstract_origin attribute. 677 off_t abstract_origin_; 678 }; 679 680 // This class is used to read the debug info from the .debug_info 681 // or .debug_types sections. This is a base class that implements 682 // the generic parsing of the compilation unit header and DIE 683 // structure. The parse() method parses the entire section, and 684 // calls the various visit_xxx() methods for each header. Clients 685 // should derive a new class from this one and implement the 686 // visit_compilation_unit() and visit_type_unit() functions. 687 688 class Dwarf_info_reader 689 { 690 public: 691 Dwarf_info_reader(bool is_type_unit, 692 Relobj* object, 693 const unsigned char* symtab, 694 off_t symtab_size, 695 unsigned int shndx, 696 unsigned int reloc_shndx, 697 unsigned int reloc_type) 698 : is_type_unit_(is_type_unit), object_(object), symtab_(symtab), 699 symtab_size_(symtab_size), shndx_(shndx), reloc_shndx_(reloc_shndx), 700 reloc_type_(reloc_type), abbrev_shndx_(0), string_shndx_(0), 701 buffer_(NULL), buffer_end_(NULL), cu_offset_(0), cu_length_(0), 702 offset_size_(0), address_size_(0), cu_version_(0), 703 abbrev_table_(), ranges_table_(this), 704 reloc_mapper_(NULL), string_buffer_(NULL), string_buffer_end_(NULL), 705 owns_string_buffer_(false), string_output_section_offset_(0) 706 { } 707 708 virtual 709 ~Dwarf_info_reader() 710 { 711 if (this->reloc_mapper_ != NULL) 712 delete this->reloc_mapper_; 713 if (this->owns_string_buffer_ && this->string_buffer_ != NULL) 714 delete[] this->string_buffer_; 715 } 716 717 // Begin parsing the debug info. This calls visit_compilation_unit() 718 // or visit_type_unit() for each compilation or type unit found in the 719 // section, and visit_die() for each top-level DIE. 720 void 721 parse(); 722 723 // Return the abbrev code entry for a CODE. 724 const Dwarf_abbrev_table::Abbrev_code* 725 get_abbrev(unsigned int code) 726 { return this->abbrev_table_.get_abbrev(code); } 727 728 // Return a pointer to the DWARF info buffer at OFFSET. 729 const unsigned char* 730 buffer_at_offset(off_t offset) const 731 { 732 const unsigned char* p = this->buffer_ + this->cu_offset_ + offset; 733 if (this->check_buffer(p + 1)) 734 return p; 735 return NULL; 736 } 737 738 // Read a possibly unaligned integer of SIZE. 739 template <int valsize> 740 inline typename elfcpp::Valtype_base<valsize>::Valtype 741 read_from_pointer(const unsigned char* source); 742 743 // Read a possibly unaligned integer of SIZE. Update SOURCE after read. 744 template <int valsize> 745 inline typename elfcpp::Valtype_base<valsize>::Valtype 746 read_from_pointer(const unsigned char** source); 747 748 // Look for a relocation at offset ATTR_OFF in the dwarf info, 749 // and return the section index and offset of the target. 750 unsigned int 751 lookup_reloc(off_t attr_off, off_t* target_off); 752 753 // Return a string from the DWARF string table. 754 const char* 755 get_string(off_t str_off, unsigned int string_shndx); 756 757 // Return the size of a DWARF offset. 758 unsigned int 759 offset_size() const 760 { return this->offset_size_; } 761 762 // Return the size of an address. 763 unsigned int 764 address_size() const 765 { return this->address_size_; } 766 767 // Return the size of a DW_FORM_ref_addr. 768 // In DWARF v2, this was the size of an address; in DWARF v3 and later, 769 // it is the size of an DWARF offset. 770 unsigned int 771 ref_addr_size() const 772 { return this->cu_version_ > 2 ? this->offset_size_ : this->address_size_; } 773 774 // Set the section index of the .debug_abbrev section. 775 // We use this if there are no relocations for the .debug_info section. 776 // If not set, the code parse() routine will search for the section by name. 777 void 778 set_abbrev_shndx(unsigned int abbrev_shndx) 779 { this->abbrev_shndx_ = abbrev_shndx; } 780 781 // Return a pointer to the object file's ELF symbol table. 782 const unsigned char* 783 symtab() const 784 { return this->symtab_; } 785 786 // Return the size of the object file's ELF symbol table. 787 off_t 788 symtab_size() const 789 { return this->symtab_size_; } 790 791 // Return the offset of the current compilation unit. 792 off_t 793 cu_offset() const 794 { return this->cu_offset_; } 795 796 protected: 797 // Begin parsing the debug info. This calls visit_compilation_unit() 798 // or visit_type_unit() for each compilation or type unit found in the 799 // section, and visit_die() for each top-level DIE. 800 template<bool big_endian> 801 void 802 do_parse(); 803 804 // The following methods are hooks that are meant to be implemented 805 // by a derived class. A default, do-nothing, implementation of 806 // each is provided for this base class. 807 808 // Visit a compilation unit. 809 virtual void 810 visit_compilation_unit(off_t cu_offset, off_t cu_length, Dwarf_die* root_die); 811 812 // Visit a type unit. 813 virtual void 814 visit_type_unit(off_t tu_offset, off_t tu_length, off_t type_offset, 815 uint64_t signature, Dwarf_die* root_die); 816 817 // Read the range table. 818 Dwarf_range_list* 819 read_range_list(unsigned int ranges_shndx, off_t ranges_offset) 820 { 821 return this->ranges_table_.read_range_list(this->object_, 822 this->symtab_, 823 this->symtab_size_, 824 this->address_size_, 825 ranges_shndx, 826 ranges_offset); 827 } 828 829 // Return the object. 830 Relobj* 831 object() const 832 { return this->object_; } 833 834 // Checkpoint the relocation tracker. 835 uint64_t 836 get_reloc_checkpoint() const 837 { return this->reloc_mapper_->checkpoint(); } 838 839 // Reset the relocation tracker to the CHECKPOINT. 840 void 841 reset_relocs(uint64_t checkpoint) 842 { this->reloc_mapper_->reset(checkpoint); } 843 844 private: 845 // Print a warning about a corrupt debug section. 846 void 847 warn_corrupt_debug_section() const; 848 849 // Check that P is within the bounds of the current section. 850 bool 851 check_buffer(const unsigned char* p) const 852 { 853 if (p > this->buffer_ + this->cu_offset_ + this->cu_length_) 854 { 855 this->warn_corrupt_debug_section(); 856 return false; 857 } 858 return true; 859 } 860 861 // Read the DWARF string table. 862 bool 863 read_string_table(unsigned int string_shndx) 864 { 865 // If we've already read this string table, return immediately. 866 if (this->string_shndx_ > 0 && this->string_shndx_ == string_shndx) 867 return true; 868 if (string_shndx == 0 && this->string_shndx_ > 0) 869 return true; 870 return this->do_read_string_table(string_shndx); 871 } 872 873 bool 874 do_read_string_table(unsigned int string_shndx); 875 876 // True if this is a type unit; false for a compilation unit. 877 bool is_type_unit_; 878 // The object containing the .debug_info or .debug_types input section. 879 Relobj* object_; 880 // The ELF symbol table. 881 const unsigned char* symtab_; 882 // The size of the ELF symbol table. 883 off_t symtab_size_; 884 // Index of the .debug_info or .debug_types section. 885 unsigned int shndx_; 886 // Index of the relocation section. 887 unsigned int reloc_shndx_; 888 // Type of the relocation section (SHT_REL or SHT_RELA). 889 unsigned int reloc_type_; 890 // Index of the .debug_abbrev section (0 if not known). 891 unsigned int abbrev_shndx_; 892 // Index of the .debug_str section. 893 unsigned int string_shndx_; 894 // The buffer for the debug info. 895 const unsigned char* buffer_; 896 const unsigned char* buffer_end_; 897 // Offset of the current compilation unit. 898 off_t cu_offset_; 899 // Length of the current compilation unit. 900 off_t cu_length_; 901 // Size of a DWARF offset for the current compilation unit. 902 unsigned int offset_size_; 903 // Size of an address for the target architecture. 904 unsigned int address_size_; 905 // Compilation unit version number. 906 unsigned int cu_version_; 907 // Abbreviations table for current compilation unit. 908 Dwarf_abbrev_table abbrev_table_; 909 // Ranges table for the current compilation unit. 910 Dwarf_ranges_table ranges_table_; 911 // Relocation mapper for the section. 912 Elf_reloc_mapper* reloc_mapper_; 913 // The buffer for the debug string table. 914 const char* string_buffer_; 915 const char* string_buffer_end_; 916 // True if this object owns the buffer and needs to delete it. 917 bool owns_string_buffer_; 918 // For incremental update links, this will hold the offset of the 919 // input .debug_str section within the output section. Offsets read 920 // from relocated data will be relative to the output section, and need 921 // to be corrected before reading data from the input section. 922 uint64_t string_output_section_offset_; 923 }; 924 925 // We can't do better than to keep the offsets in a sorted vector. 926 // Here, offset is the key, and file_num/line_num is the value. 927 struct Offset_to_lineno_entry 928 { 929 off_t offset; 930 int header_num; // which file-list to use (i.e. which .o file are we in) 931 // A pointer into files_. 932 unsigned int file_num : sizeof(int) * CHAR_BIT - 1; 933 // True if this was the last entry for the current offset, meaning 934 // it's the line that actually applies. 935 unsigned int last_line_for_offset : 1; 936 // The line number in the source file. -1 to indicate end-of-function. 937 int line_num; 938 939 // This sorts by offsets first, and then puts the correct line to 940 // report for a given offset at the beginning of the run of equal 941 // offsets (so that asking for 1 line gives the best answer). This 942 // is not a total ordering. 943 bool operator<(const Offset_to_lineno_entry& that) const 944 { 945 if (this->offset != that.offset) 946 return this->offset < that.offset; 947 // Note the '>' which makes this sort 'true' first. 948 return this->last_line_for_offset > that.last_line_for_offset; 949 } 950 }; 951 952 // This class is used to read the line information from the debugging 953 // section of an object file. 954 955 class Dwarf_line_info 956 { 957 public: 958 Dwarf_line_info() 959 { } 960 961 virtual 962 ~Dwarf_line_info() 963 { } 964 965 // Given a section number and an offset, returns the associated 966 // file and line-number, as a string: "file:lineno". If unable 967 // to do the mapping, returns the empty string. You must call 968 // read_line_mappings() before calling this function. If 969 // 'other_lines' is non-NULL, fills that in with other line 970 // numbers assigned to the same offset. 971 std::string 972 addr2line(unsigned int shndx, off_t offset, 973 std::vector<std::string>* other_lines) 974 { return this->do_addr2line(shndx, offset, other_lines); } 975 976 // A helper function for a single addr2line lookup. It also keeps a 977 // cache of the last CACHE_SIZE Dwarf_line_info objects it created; 978 // set to 0 not to cache at all. The larger CACHE_SIZE is, the more 979 // chance this routine won't have to re-create a Dwarf_line_info 980 // object for its addr2line computation; such creations are slow. 981 // NOTE: Not thread-safe, so only call from one thread at a time. 982 static std::string 983 one_addr2line(Object* object, unsigned int shndx, off_t offset, 984 size_t cache_size, std::vector<std::string>* other_lines); 985 986 // This reclaims all the memory that one_addr2line may have cached. 987 // Use this when you know you will not be calling one_addr2line again. 988 static void 989 clear_addr2line_cache(); 990 991 private: 992 virtual std::string 993 do_addr2line(unsigned int shndx, off_t offset, 994 std::vector<std::string>* other_lines) = 0; 995 }; 996 997 template<int size, bool big_endian> 998 class Sized_dwarf_line_info : public Dwarf_line_info 999 { 1000 public: 1001 // Initializes a .debug_line reader for a given object file. 1002 // If SHNDX is specified and non-negative, only read the debug 1003 // information that pertains to the specified section. 1004 Sized_dwarf_line_info(Object* object, unsigned int read_shndx = -1U); 1005 1006 virtual 1007 ~Sized_dwarf_line_info() 1008 { 1009 if (this->buffer_start_ != NULL) 1010 delete[] this->buffer_start_; 1011 } 1012 1013 private: 1014 std::string 1015 do_addr2line(unsigned int shndx, off_t offset, 1016 std::vector<std::string>* other_lines); 1017 1018 // Formats a file and line number to a string like "dirname/filename:lineno". 1019 std::string 1020 format_file_lineno(const Offset_to_lineno_entry& lineno) const; 1021 1022 // Start processing line info, and populates the offset_map_. 1023 // If SHNDX is non-negative, only store debug information that 1024 // pertains to the specified section. 1025 void 1026 read_line_mappings(unsigned int shndx); 1027 1028 // Reads the relocation section associated with .debug_line and 1029 // stores relocation information in reloc_map_. 1030 void 1031 read_relocs(); 1032 1033 // Reads the DWARF2/3 header for this line info. Each takes as input 1034 // a starting buffer position, and returns the ending position. 1035 const unsigned char* 1036 read_header_prolog(const unsigned char* lineptr); 1037 1038 const unsigned char* 1039 read_header_tables(const unsigned char* lineptr); 1040 1041 // Reads the DWARF2/3 line information. If shndx is non-negative, 1042 // discard all line information that doesn't pertain to the given 1043 // section. 1044 const unsigned char* 1045 read_lines(const unsigned char* lineptr, unsigned int shndx); 1046 1047 // Process a single line info opcode at START using the state 1048 // machine at LSM. Return true if we should define a line using the 1049 // current state of the line state machine. Place the length of the 1050 // opcode in LEN. 1051 bool 1052 process_one_opcode(const unsigned char* start, 1053 struct LineStateMachine* lsm, size_t* len); 1054 1055 // Some parts of processing differ depending on whether the input 1056 // was a .o file or not. 1057 bool input_is_relobj(); 1058 1059 // If we saw anything amiss while parsing, we set this to false. 1060 // Then addr2line will always fail (rather than return possibly- 1061 // corrupt data). 1062 bool data_valid_; 1063 1064 // A DWARF2/3 line info header. This is not the same size as in the 1065 // actual file, as the one in the file may have a 32 bit or 64 bit 1066 // lengths. 1067 1068 struct Dwarf_line_infoHeader 1069 { 1070 off_t total_length; 1071 int version; 1072 off_t prologue_length; 1073 int min_insn_length; // insn stands for instruction 1074 int max_ops_per_insn; // Added in DWARF-4. 1075 bool default_is_stmt; // stmt stands for statement 1076 signed char line_base; 1077 int line_range; 1078 unsigned char opcode_base; 1079 std::vector<unsigned char> std_opcode_lengths; 1080 int offset_size; 1081 } header_; 1082 1083 // buffer is the buffer for our line info, starting at exactly where 1084 // the line info to read is. 1085 const unsigned char* buffer_; 1086 const unsigned char* buffer_end_; 1087 // If the buffer was allocated temporarily, and therefore must be 1088 // deallocated in the dtor, this contains a pointer to the start 1089 // of the buffer. 1090 const unsigned char* buffer_start_; 1091 1092 // This has relocations that point into buffer. 1093 Sized_elf_reloc_mapper<size, big_endian>* reloc_mapper_; 1094 // The type of the reloc section in track_relocs_--SHT_REL or SHT_RELA. 1095 unsigned int track_relocs_type_; 1096 1097 // This is used to figure out what section to apply a relocation to. 1098 const unsigned char* symtab_buffer_; 1099 section_size_type symtab_buffer_size_; 1100 1101 // Holds the directories and files as we see them. We have an array 1102 // of directory-lists, one for each .o file we're reading (usually 1103 // there will just be one, but there may be more if input is a .so). 1104 std::vector<std::vector<std::string> > directories_; 1105 // The first part is an index into directories_, the second the filename. 1106 std::vector<std::vector< std::pair<int, std::string> > > files_; 1107 1108 // An index into the current directories_ and files_ vectors. 1109 int current_header_index_; 1110 1111 // A sorted map from offset of the relocation target to the shndx 1112 // and addend for the relocation. 1113 typedef std::map<off_t, std::pair<unsigned int, off_t> > 1114 Reloc_map; 1115 Reloc_map reloc_map_; 1116 1117 // We have a vector of offset->lineno entries for every input section. 1118 typedef Unordered_map<unsigned int, std::vector<Offset_to_lineno_entry> > 1119 Lineno_map; 1120 1121 Lineno_map line_number_map_; 1122 }; 1123 1124 } // End namespace gold. 1125 1126 #endif // !defined(GOLD_DWARF_READER_H) 1127