1 // dwarf_reader.h -- parse dwarf2/3 debug information for gold -*- C++ -*-
3 // Copyright 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
6 // This file is part of gold.
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.
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.
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.
23 #ifndef GOLD_DWARF_READER_H
24 #define GOLD_DWARF_READER_H
29 #include <sys/types.h>
32 #include "elfcpp_swap.h"
39 class Dwarf_info_reader
;
40 struct LineStateMachine
;
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.
45 class Elf_reloc_mapper
55 // Initialize the relocation tracker for section RELOC_SHNDX.
57 initialize(unsigned int reloc_shndx
, unsigned int reloc_type
)
58 { return this->do_initialize(reloc_shndx
, reloc_type
); }
60 // Return the next reloc_offset.
63 { return this->do_next_offset(); }
65 // Advance to the next relocation past OFFSET.
68 { this->do_advance(offset
); }
70 // Return the section index and offset within the section of the target
71 // of the relocation for RELOC_OFFSET in the referring section.
73 get_reloc_target(off_t reloc_offset
, off_t
* target_offset
)
74 { return this->do_get_reloc_target(reloc_offset
, target_offset
); }
76 // Checkpoint the current position in the reloc section.
79 { return this->do_checkpoint(); }
81 // Reset the current position to the CHECKPOINT.
83 reset(uint64_t checkpoint
)
84 { this->do_reset(checkpoint
); }
88 do_initialize(unsigned int, unsigned int) = 0;
90 // Return the next reloc_offset.
94 // Advance to the next relocation past OFFSET.
96 do_advance(off_t offset
) = 0;
99 do_get_reloc_target(off_t reloc_offset
, off_t
* target_offset
) = 0;
101 // Checkpoint the current position in the reloc section.
103 do_checkpoint() const = 0;
105 // Reset the current position to the CHECKPOINT.
107 do_reset(uint64_t checkpoint
) = 0;
110 template<int size
, bool big_endian
>
111 class Sized_elf_reloc_mapper
: public Elf_reloc_mapper
114 Sized_elf_reloc_mapper(Object
* object
, const unsigned char* symtab
,
116 : object_(object
), symtab_(symtab
), symtab_size_(symtab_size
),
117 reloc_type_(0), track_relocs_()
122 do_initialize(unsigned int reloc_shndx
, unsigned int reloc_type
);
124 // Return the next reloc_offset.
127 { return this->track_relocs_
.next_offset(); }
129 // Advance to the next relocation past OFFSET.
131 do_advance(off_t offset
)
132 { this->track_relocs_
.advance(offset
); }
135 do_get_reloc_target(off_t reloc_offset
, off_t
* target_offset
);
137 // Checkpoint the current position in the reloc section.
139 do_checkpoint() const
140 { return this->track_relocs_
.checkpoint(); }
142 // Reset the current position to the CHECKPOINT.
144 do_reset(uint64_t checkpoint
)
145 { this->track_relocs_
.reset(checkpoint
); }
148 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Address
;
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.
153 symbol_section(unsigned int symndx
, Address
* value
, bool* is_ordinary
);
157 // The ELF symbol table.
158 const unsigned char* symtab_
;
159 // The size of the ELF symbol table.
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_
;
167 // This class is used to read the abbreviations table from the
168 // .debug_abbrev section of the object file.
170 class Dwarf_abbrev_table
173 // An attribute list entry.
176 Attribute(unsigned int a
, unsigned int f
)
183 // An abbrev code entry.
186 Abbrev_code(unsigned int t
, bool hc
)
187 : tag(t
), has_children(hc
), has_sibling_attribute(false), attributes()
189 this->attributes
.reserve(10);
193 add_attribute(unsigned int attr
, unsigned int form
)
195 this->attributes
.push_back(Attribute(attr
, form
));
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
;
209 : abbrev_shndx_(0), abbrev_offset_(0), buffer_(NULL
), buffer_end_(NULL
),
210 owns_buffer_(false), buffer_pos_(NULL
), high_abbrev_codes_()
212 memset(this->low_abbrev_codes_
, 0, sizeof(this->low_abbrev_codes_
));
215 ~Dwarf_abbrev_table()
217 if (this->owns_buffer_
&& this->buffer_
!= NULL
)
218 delete[] this->buffer_
;
219 this->clear_abbrev_codes();
222 // Read the abbrev table from an object file.
224 read_abbrevs(Relobj
* object
,
225 unsigned int abbrev_shndx
,
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
)
233 return this->do_read_abbrevs(object
, abbrev_shndx
, abbrev_offset
);
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.
240 get_abbrev(unsigned int code
)
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
);
249 // Read the abbrev table from an object file.
251 do_read_abbrevs(Relobj
* object
,
252 unsigned int abbrev_shndx
,
253 off_t abbrev_offset
);
255 // Lookup the abbrev code entry for CODE.
257 do_get_abbrev(unsigned int code
);
259 // Store an abbrev code entry for CODE.
261 store_abbrev(unsigned int code
, const Abbrev_code
* entry
)
263 if (code
< this->low_abbrev_code_max_
)
264 this->low_abbrev_codes_
[code
] = entry
;
266 this->high_abbrev_codes_
[code
] = entry
;
269 // Clear the abbrev code table and release the memory it uses.
271 clear_abbrev_codes();
273 typedef Unordered_map
<unsigned int, const Abbrev_code
*> Abbrev_code_table
;
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.
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_
;
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.
298 class Dwarf_range_list
303 Range(unsigned int a_shndx
, off_t a_start
, off_t a_end
)
304 : shndx(a_shndx
), start(a_start
), end(a_end
)
317 add(unsigned int shndx
, off_t start
, off_t end
)
318 { this->range_list_
.push_back(Range(shndx
, start
, end
)); }
322 { return this->range_list_
.size(); }
325 operator[](off_t i
) const
326 { return this->range_list_
[i
]; }
329 std::vector
<Range
> range_list_
;
332 // This class is used to read the ranges table from the
333 // .debug_ranges section of the object file.
335 class Dwarf_ranges_table
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)
344 ~Dwarf_ranges_table()
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_
;
352 // Read the ranges table from an object file.
354 read_ranges_table(Relobj
* object
,
355 const unsigned char* symtab
,
357 unsigned int ranges_shndx
);
359 // Read the range table from an object file.
361 read_range_list(Relobj
* object
,
362 const unsigned char* symtab
,
364 unsigned int address_size
,
365 unsigned int ranges_shndx
,
366 off_t ranges_offset
);
368 // Look for a relocation at offset OFF in the range table,
369 // and return the section index and offset of the target.
371 lookup_reloc(off_t off
, off_t
* target_off
);
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_
;
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.
397 class Dwarf_pubnames_table
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
), is_pubtypes_(is_pubtypes
),
403 output_section_offset_(0), unit_length_(0), cu_offset_(0)
406 ~Dwarf_pubnames_table()
408 if (this->owns_buffer_
&& this->buffer_
!= NULL
)
409 delete[] this->buffer_
;
412 // Read the pubnames section from the object file, using the symbol
413 // table for relocating it.
415 read_section(Relobj
* object
, const unsigned char* symbol_table
,
418 // Read the header for the set at OFFSET.
420 read_header(off_t offset
);
422 // Return the offset to the cu within the info or types section.
425 { return this->cu_offset_
; }
427 // Return the size of this subsection of the table. The unit length
428 // doesn't include the size of its own field.
431 { return this->unit_length_
; }
433 // Read the next name from the set.
438 // The Dwarf_info_reader, for reading data.
439 Dwarf_info_reader
* dwinfo_
;
440 // The buffer containing the .debug_ranges section.
441 const unsigned char* buffer_
;
442 const unsigned char* buffer_end_
;
443 // True if this object owns the buffer and needs to delete it.
445 // The size of a DWARF offset for the current set.
446 unsigned int offset_size_
;
447 // The current position within the buffer.
448 const unsigned char* pinfo_
;
449 // TRUE if this is a .debug_pubtypes section.
451 // For incremental update links, this will hold the offset of the
452 // input section within the output section. Offsets read from
453 // relocated data will be relative to the output section, and need
454 // to be corrected before reading data from the input section.
455 uint64_t output_section_offset_
;
456 // Fields read from the header.
457 uint64_t unit_length_
;
460 // Track relocations for this table so we can find the CUs that
461 // correspond to the subsections.
462 Elf_reloc_mapper
* reloc_mapper_
;
463 // Type of the relocation section (SHT_REL or SHT_RELA).
464 unsigned int reloc_type_
;
467 // This class represents a DWARF Debug Info Entry (DIE).
472 // An attribute value.
473 struct Attribute_value
481 const char* stringval
;
482 const unsigned char* blockval
;
487 // Section index for reference forms.
489 // Block length for block forms.
490 unsigned int blocklen
;
491 // Attribute offset for DW_FORM_strp.
492 unsigned int attr_off
;
496 // A list of attribute values.
497 typedef std::vector
<Attribute_value
> Attributes
;
499 Dwarf_die(Dwarf_info_reader
* dwinfo
,
503 // Return the DWARF tag for this DIE.
507 if (this->abbrev_code_
== NULL
)
509 return this->abbrev_code_
->tag
;
512 // Return true if this DIE has children.
516 gold_assert(this->abbrev_code_
!= NULL
);
517 return this->abbrev_code_
->has_children
;
520 // Return true if this DIE has a sibling attribute.
522 has_sibling_attribute() const
524 gold_assert(this->abbrev_code_
!= NULL
);
525 return this->abbrev_code_
->has_sibling_attribute
;
528 // Return the value of attribute ATTR.
529 const Attribute_value
*
530 attribute(unsigned int attr
);
532 // Return the value of the DW_AT_name attribute.
536 if (this->name_
== NULL
)
541 // Return the value of the DW_AT_linkage_name
542 // or DW_AT_MIPS_linkage_name attribute.
546 if (this->linkage_name_
== NULL
)
547 this->set_linkage_name();
548 return this->linkage_name_
;
551 // Return the value of the DW_AT_specification attribute.
555 if (!this->attributes_read_
)
556 this->read_attributes();
557 return this->specification_
;
560 // Return the value of the DW_AT_abstract_origin attribute.
564 if (!this->attributes_read_
)
565 this->read_attributes();
566 return this->abstract_origin_
;
569 // Return the value of attribute ATTR as a string.
571 string_attribute(unsigned int attr
);
573 // Return the value of attribute ATTR as an integer.
575 int_attribute(unsigned int attr
);
577 // Return the value of attribute ATTR as an unsigned integer.
579 uint_attribute(unsigned int attr
);
581 // Return the value of attribute ATTR as a reference.
583 ref_attribute(unsigned int attr
, unsigned int* shndx
);
585 // Return the value of attribute ATTR as a address.
587 address_attribute(unsigned int attr
, unsigned int* shndx
);
589 // Return the value of attribute ATTR as a flag.
591 flag_attribute(unsigned int attr
)
592 { return this->int_attribute(attr
) != 0; }
594 // Return true if this DIE is a declaration.
597 { return this->flag_attribute(elfcpp::DW_AT_declaration
); }
599 // Return the parent of this DIE.
602 { return this->parent_
; }
604 // Return the offset of this DIE.
607 { return this->die_offset_
; }
609 // Return the offset of this DIE's first child.
613 // Set the offset of this DIE's next sibling.
615 set_sibling_offset(off_t sibling_offset
)
616 { this->sibling_offset_
= sibling_offset
; }
618 // Return the offset of this DIE's next sibling.
623 typedef Dwarf_abbrev_table::Abbrev_code Abbrev_code
;
625 // Read all the attributes of the DIE.
629 // Set the name of the DIE if present.
633 // Set the linkage name if present.
637 // Skip all the attributes of the DIE and return the offset
642 // The Dwarf_info_reader, for reading attributes.
643 Dwarf_info_reader
* dwinfo_
;
644 // The parent of this DIE.
646 // Offset of this DIE within its compilation unit.
648 // Offset of the first attribute, relative to the beginning of the DIE.
650 // Offset of the first child, relative to the compilation unit.
652 // Offset of the next sibling, relative to the compilation unit.
653 off_t sibling_offset_
;
654 // The abbreviation table entry.
655 const Abbrev_code
* abbrev_code_
;
656 // The list of attributes.
657 Attributes attributes_
;
658 // True if the attributes have been read.
659 bool attributes_read_
;
660 // The following fields hold common attributes to avoid a linear
661 // search through the attribute list.
662 // The DIE name (DW_AT_name).
664 // Offset of the name in the string table (for DW_FORM_strp).
666 // The linkage name (DW_AT_linkage_name or DW_AT_MIPS_linkage_name).
667 const char* linkage_name_
;
668 // Offset of the linkage name in the string table (for DW_FORM_strp).
669 off_t linkage_name_off_
;
670 // Section index of the string table (for DW_FORM_strp).
671 unsigned int string_shndx_
;
672 // The value of a DW_AT_specification attribute.
673 off_t specification_
;
674 // The value of a DW_AT_abstract_origin attribute.
675 off_t abstract_origin_
;
678 // This class is used to read the debug info from the .debug_info
679 // or .debug_types sections. This is a base class that implements
680 // the generic parsing of the compilation unit header and DIE
681 // structure. The parse() method parses the entire section, and
682 // calls the various visit_xxx() methods for each header. Clients
683 // should derive a new class from this one and implement the
684 // visit_compilation_unit() and visit_type_unit() functions.
686 class Dwarf_info_reader
689 Dwarf_info_reader(bool is_type_unit
,
691 const unsigned char* symtab
,
694 unsigned int reloc_shndx
,
695 unsigned int reloc_type
)
696 : is_type_unit_(is_type_unit
), object_(object
), symtab_(symtab
),
697 symtab_size_(symtab_size
), shndx_(shndx
), reloc_shndx_(reloc_shndx
),
698 reloc_type_(reloc_type
), abbrev_shndx_(0), string_shndx_(0),
699 buffer_(NULL
), buffer_end_(NULL
), cu_offset_(0), cu_length_(0),
700 offset_size_(0), address_size_(0), cu_version_(0), type_signature_(0),
701 type_offset_(0), abbrev_table_(), ranges_table_(this),
702 reloc_mapper_(NULL
), string_buffer_(NULL
), string_buffer_end_(NULL
),
703 owns_string_buffer_(false), string_output_section_offset_(0)
709 if (this->reloc_mapper_
!= NULL
)
710 delete this->reloc_mapper_
;
711 if (this->owns_string_buffer_
&& this->string_buffer_
!= NULL
)
712 delete[] this->string_buffer_
;
715 // Begin parsing the debug info. This calls visit_compilation_unit()
716 // or visit_type_unit() for each compilation or type unit found in the
717 // section, and visit_die() for each top-level DIE.
721 // Return the abbrev code entry for a CODE.
722 const Dwarf_abbrev_table::Abbrev_code
*
723 get_abbrev(unsigned int code
)
724 { return this->abbrev_table_
.get_abbrev(code
); }
726 // Return a pointer to the DWARF info buffer at OFFSET.
728 buffer_at_offset(off_t offset
) const
730 const unsigned char* p
= this->buffer_
+ this->cu_offset_
+ offset
;
731 if (this->check_buffer(p
+ 1))
736 // Read a possibly unaligned integer of SIZE.
737 template <int valsize
>
738 inline typename
elfcpp::Valtype_base
<valsize
>::Valtype
739 read_from_pointer(const unsigned char* source
);
741 // Read a possibly unaligned integer of SIZE. Update SOURCE after read.
742 template <int valsize
>
743 inline typename
elfcpp::Valtype_base
<valsize
>::Valtype
744 read_from_pointer(const unsigned char** source
);
746 // Look for a relocation at offset ATTR_OFF in the dwarf info,
747 // and return the section index and offset of the target.
749 lookup_reloc(off_t attr_off
, off_t
* target_off
);
751 // Return a string from the DWARF string table.
753 get_string(off_t str_off
, unsigned int string_shndx
);
755 // Return the size of a DWARF offset.
758 { return this->offset_size_
; }
760 // Return the size of an address.
763 { return this->address_size_
; }
765 // Set the section index of the .debug_abbrev section.
766 // We use this if there are no relocations for the .debug_info section.
767 // If not set, the code parse() routine will search for the section by name.
769 set_abbrev_shndx(unsigned int abbrev_shndx
)
770 { this->abbrev_shndx_
= abbrev_shndx
; }
772 // Return a pointer to the object file's ELF symbol table.
775 { return this->symtab_
; }
777 // Return the size of the object file's ELF symbol table.
780 { return this->symtab_size_
; }
782 // Return the offset of the current compilation unit.
785 { return this->cu_offset_
; }
788 // Begin parsing the debug info. This calls visit_compilation_unit()
789 // or visit_type_unit() for each compilation or type unit found in the
790 // section, and visit_die() for each top-level DIE.
791 template<bool big_endian
>
795 // The following methods are hooks that are meant to be implemented
796 // by a derived class. A default, do-nothing, implementation of
797 // each is provided for this base class.
799 // Visit a compilation unit.
801 visit_compilation_unit(off_t cu_offset
, off_t cu_length
, Dwarf_die
* root_die
);
803 // Visit a type unit.
805 visit_type_unit(off_t tu_offset
, off_t tu_length
, off_t type_offset
,
806 uint64_t signature
, Dwarf_die
* root_die
);
808 // Read the range table.
810 read_range_list(unsigned int ranges_shndx
, off_t ranges_offset
)
812 return this->ranges_table_
.read_range_list(this->object_
,
820 // Return the object.
823 { return this->object_
; }
825 // Checkpoint the relocation tracker.
827 get_reloc_checkpoint() const
828 { return this->reloc_mapper_
->checkpoint(); }
830 // Reset the relocation tracker to the CHECKPOINT.
832 reset_relocs(uint64_t checkpoint
)
833 { this->reloc_mapper_
->reset(checkpoint
); }
836 // Print a warning about a corrupt debug section.
838 warn_corrupt_debug_section() const;
840 // Check that P is within the bounds of the current section.
842 check_buffer(const unsigned char* p
) const
844 if (p
> this->buffer_
+ this->cu_offset_
+ this->cu_length_
)
846 this->warn_corrupt_debug_section();
852 // Read the DWARF string table.
854 read_string_table(unsigned int string_shndx
)
856 // If we've already read this string table, return immediately.
857 if (this->string_shndx_
> 0 && this->string_shndx_
== string_shndx
)
859 if (string_shndx
== 0 && this->string_shndx_
> 0)
861 return this->do_read_string_table(string_shndx
);
865 do_read_string_table(unsigned int string_shndx
);
867 // True if this is a type unit; false for a compilation unit.
869 // The object containing the .debug_info or .debug_types input section.
871 // The ELF symbol table.
872 const unsigned char* symtab_
;
873 // The size of the ELF symbol table.
875 // Index of the .debug_info or .debug_types section.
877 // Index of the relocation section.
878 unsigned int reloc_shndx_
;
879 // Type of the relocation section (SHT_REL or SHT_RELA).
880 unsigned int reloc_type_
;
881 // Index of the .debug_abbrev section (0 if not known).
882 unsigned int abbrev_shndx_
;
883 // Index of the .debug_str section.
884 unsigned int string_shndx_
;
885 // The buffer for the debug info.
886 const unsigned char* buffer_
;
887 const unsigned char* buffer_end_
;
888 // Offset of the current compilation unit.
890 // Length of the current compilation unit.
892 // Size of a DWARF offset for the current compilation unit.
893 unsigned int offset_size_
;
894 // Size of an address for the target architecture.
895 unsigned int address_size_
;
896 // Compilation unit version number.
897 unsigned int cu_version_
;
898 // Type signature (for a type unit).
899 uint64_t type_signature_
;
900 // Offset from the type unit header to the type DIE (for a type unit).
902 // Abbreviations table for current compilation unit.
903 Dwarf_abbrev_table abbrev_table_
;
904 // Ranges table for the current compilation unit.
905 Dwarf_ranges_table ranges_table_
;
906 // Relocation mapper for the section.
907 Elf_reloc_mapper
* reloc_mapper_
;
908 // The buffer for the debug string table.
909 const char* string_buffer_
;
910 const char* string_buffer_end_
;
911 // True if this object owns the buffer and needs to delete it.
912 bool owns_string_buffer_
;
913 // For incremental update links, this will hold the offset of the
914 // input .debug_str section within the output section. Offsets read
915 // from relocated data will be relative to the output section, and need
916 // to be corrected before reading data from the input section.
917 uint64_t string_output_section_offset_
;
920 // We can't do better than to keep the offsets in a sorted vector.
921 // Here, offset is the key, and file_num/line_num is the value.
922 struct Offset_to_lineno_entry
925 int header_num
; // which file-list to use (i.e. which .o file are we in)
926 // A pointer into files_.
927 unsigned int file_num
: sizeof(int) * CHAR_BIT
- 1;
928 // True if this was the last entry for the current offset, meaning
929 // it's the line that actually applies.
930 unsigned int last_line_for_offset
: 1;
931 // The line number in the source file. -1 to indicate end-of-function.
934 // This sorts by offsets first, and then puts the correct line to
935 // report for a given offset at the beginning of the run of equal
936 // offsets (so that asking for 1 line gives the best answer). This
937 // is not a total ordering.
938 bool operator<(const Offset_to_lineno_entry
& that
) const
940 if (this->offset
!= that
.offset
)
941 return this->offset
< that
.offset
;
942 // Note the '>' which makes this sort 'true' first.
943 return this->last_line_for_offset
> that
.last_line_for_offset
;
947 // This class is used to read the line information from the debugging
948 // section of an object file.
950 class Dwarf_line_info
960 // Given a section number and an offset, returns the associated
961 // file and line-number, as a string: "file:lineno". If unable
962 // to do the mapping, returns the empty string. You must call
963 // read_line_mappings() before calling this function. If
964 // 'other_lines' is non-NULL, fills that in with other line
965 // numbers assigned to the same offset.
967 addr2line(unsigned int shndx
, off_t offset
,
968 std::vector
<std::string
>* other_lines
)
969 { return this->do_addr2line(shndx
, offset
, other_lines
); }
971 // A helper function for a single addr2line lookup. It also keeps a
972 // cache of the last CACHE_SIZE Dwarf_line_info objects it created;
973 // set to 0 not to cache at all. The larger CACHE_SIZE is, the more
974 // chance this routine won't have to re-create a Dwarf_line_info
975 // object for its addr2line computation; such creations are slow.
976 // NOTE: Not thread-safe, so only call from one thread at a time.
978 one_addr2line(Object
* object
, unsigned int shndx
, off_t offset
,
979 size_t cache_size
, std::vector
<std::string
>* other_lines
);
981 // This reclaims all the memory that one_addr2line may have cached.
982 // Use this when you know you will not be calling one_addr2line again.
984 clear_addr2line_cache();
988 do_addr2line(unsigned int shndx
, off_t offset
,
989 std::vector
<std::string
>* other_lines
) = 0;
992 template<int size
, bool big_endian
>
993 class Sized_dwarf_line_info
: public Dwarf_line_info
996 // Initializes a .debug_line reader for a given object file.
997 // If SHNDX is specified and non-negative, only read the debug
998 // information that pertains to the specified section.
999 Sized_dwarf_line_info(Object
* object
, unsigned int read_shndx
= -1U);
1002 ~Sized_dwarf_line_info()
1004 if (this->buffer_start_
!= NULL
)
1005 delete[] this->buffer_start_
;
1010 do_addr2line(unsigned int shndx
, off_t offset
,
1011 std::vector
<std::string
>* other_lines
);
1013 // Formats a file and line number to a string like "dirname/filename:lineno".
1015 format_file_lineno(const Offset_to_lineno_entry
& lineno
) const;
1017 // Start processing line info, and populates the offset_map_.
1018 // If SHNDX is non-negative, only store debug information that
1019 // pertains to the specified section.
1021 read_line_mappings(unsigned int shndx
);
1023 // Reads the relocation section associated with .debug_line and
1024 // stores relocation information in reloc_map_.
1028 // Reads the DWARF2/3 header for this line info. Each takes as input
1029 // a starting buffer position, and returns the ending position.
1030 const unsigned char*
1031 read_header_prolog(const unsigned char* lineptr
);
1033 const unsigned char*
1034 read_header_tables(const unsigned char* lineptr
);
1036 // Reads the DWARF2/3 line information. If shndx is non-negative,
1037 // discard all line information that doesn't pertain to the given
1039 const unsigned char*
1040 read_lines(const unsigned char* lineptr
, unsigned int shndx
);
1042 // Process a single line info opcode at START using the state
1043 // machine at LSM. Return true if we should define a line using the
1044 // current state of the line state machine. Place the length of the
1047 process_one_opcode(const unsigned char* start
,
1048 struct LineStateMachine
* lsm
, size_t* len
);
1050 // Some parts of processing differ depending on whether the input
1051 // was a .o file or not.
1052 bool input_is_relobj();
1054 // If we saw anything amiss while parsing, we set this to false.
1055 // Then addr2line will always fail (rather than return possibly-
1059 // A DWARF2/3 line info header. This is not the same size as in the
1060 // actual file, as the one in the file may have a 32 bit or 64 bit
1063 struct Dwarf_line_infoHeader
1067 off_t prologue_length
;
1068 int min_insn_length
; // insn stands for instructin
1069 bool default_is_stmt
; // stmt stands for statement
1070 signed char line_base
;
1072 unsigned char opcode_base
;
1073 std::vector
<unsigned char> std_opcode_lengths
;
1077 // buffer is the buffer for our line info, starting at exactly where
1078 // the line info to read is.
1079 const unsigned char* buffer_
;
1080 const unsigned char* buffer_end_
;
1081 // If the buffer was allocated temporarily, and therefore must be
1082 // deallocated in the dtor, this contains a pointer to the start
1084 const unsigned char* buffer_start_
;
1086 // This has relocations that point into buffer.
1087 Sized_elf_reloc_mapper
<size
, big_endian
>* reloc_mapper_
;
1088 // The type of the reloc section in track_relocs_--SHT_REL or SHT_RELA.
1089 unsigned int track_relocs_type_
;
1091 // This is used to figure out what section to apply a relocation to.
1092 const unsigned char* symtab_buffer_
;
1093 section_size_type symtab_buffer_size_
;
1095 // Holds the directories and files as we see them. We have an array
1096 // of directory-lists, one for each .o file we're reading (usually
1097 // there will just be one, but there may be more if input is a .so).
1098 std::vector
<std::vector
<std::string
> > directories_
;
1099 // The first part is an index into directories_, the second the filename.
1100 std::vector
<std::vector
< std::pair
<int, std::string
> > > files_
;
1102 // An index into the current directories_ and files_ vectors.
1103 int current_header_index_
;
1105 // A sorted map from offset of the relocation target to the shndx
1106 // and addend for the relocation.
1107 typedef std::map
<off_t
, std::pair
<unsigned int, off_t
> >
1109 Reloc_map reloc_map_
;
1111 // We have a vector of offset->lineno entries for every input section.
1112 typedef Unordered_map
<unsigned int, std::vector
<Offset_to_lineno_entry
> >
1115 Lineno_map line_number_map_
;
1118 } // End namespace gold.
1120 #endif // !defined(GOLD_DWARF_READER_H)