You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1299 lines
41 KiB
1299 lines
41 KiB
diff -rup binutils.orig/elfcpp/dwarf.h binutils-2.35.2/elfcpp/dwarf.h |
|
--- binutils.orig/elfcpp/dwarf.h 2023-04-19 12:23:43.626095364 +0100 |
|
+++ binutils-2.35.2/elfcpp/dwarf.h 2023-04-19 12:23:58.356084971 +0100 |
|
@@ -152,35 +152,48 @@ enum DW_EH_PE |
|
DW_EH_PE_indirect = 0x80 |
|
}; |
|
|
|
+// Line number table content type codes. |
|
+ |
|
+enum DW_LNCT |
|
+{ |
|
+ DW_LNCT_path = 0x1, |
|
+ DW_LNCT_directory_index = 0x2, |
|
+ DW_LNCT_timestamp = 0x3, |
|
+ DW_LNCT_size = 0x4, |
|
+ DW_LNCT_MD5 = 0x5, |
|
+ DW_LNCT_lo_user = 0x2000, |
|
+ DW_LNCT_hi_user = 0x3fff |
|
+}; |
|
+ |
|
// Line number opcodes. |
|
|
|
enum DW_LINE_OPS |
|
{ |
|
- DW_LNS_extended_op = 0, |
|
- DW_LNS_copy = 1, |
|
- DW_LNS_advance_pc = 2, |
|
- DW_LNS_advance_line = 3, |
|
- DW_LNS_set_file = 4, |
|
- DW_LNS_set_column = 5, |
|
- DW_LNS_negate_stmt = 6, |
|
- DW_LNS_set_basic_block = 7, |
|
- DW_LNS_const_add_pc = 8, |
|
- DW_LNS_fixed_advance_pc = 9, |
|
+ DW_LNS_extended_op = 0x00, |
|
+ DW_LNS_copy = 0x01, |
|
+ DW_LNS_advance_pc = 0x02, |
|
+ DW_LNS_advance_line = 0x03, |
|
+ DW_LNS_set_file = 0x04, |
|
+ DW_LNS_set_column = 0x05, |
|
+ DW_LNS_negate_stmt = 0x06, |
|
+ DW_LNS_set_basic_block = 0x07, |
|
+ DW_LNS_const_add_pc = 0x08, |
|
+ DW_LNS_fixed_advance_pc = 0x09, |
|
// DWARF 3. |
|
- DW_LNS_set_prologue_end = 10, |
|
- DW_LNS_set_epilogue_begin = 11, |
|
- DW_LNS_set_isa = 12 |
|
+ DW_LNS_set_prologue_end = 0x0a, |
|
+ DW_LNS_set_epilogue_begin = 0x0b, |
|
+ DW_LNS_set_isa = 0x0c |
|
}; |
|
|
|
// Line number extended opcodes. |
|
|
|
enum DW_LINE_EXTENDED_OPS |
|
{ |
|
- DW_LNE_end_sequence = 1, |
|
- DW_LNE_set_address = 2, |
|
- DW_LNE_define_file = 3, |
|
+ DW_LNE_end_sequence = 0x01, |
|
+ DW_LNE_set_address = 0x02, |
|
+ DW_LNE_define_file = 0x03, |
|
// DWARF4. |
|
- DW_LNE_set_discriminator = 4, |
|
+ DW_LNE_set_discriminator = 0x04, |
|
// HP extensions. |
|
DW_LNE_HP_negate_is_UV_update = 0x11, |
|
DW_LNE_HP_push_context = 0x12, |
|
@@ -191,13 +204,15 @@ enum DW_LINE_EXTENDED_OPS |
|
DW_LNE_HP_negate_post_semantics = 0x17, |
|
DW_LNE_HP_negate_function_exit = 0x18, |
|
DW_LNE_HP_negate_front_end_logical = 0x19, |
|
- DW_LNE_HP_define_proc = 0x20 |
|
+ DW_LNE_HP_define_proc = 0x20, |
|
+ DW_LNE_lo_user = 0x80, |
|
+ DW_LNE_hi_user = 0xff |
|
}; |
|
|
|
enum DW_CHILDREN |
|
{ |
|
- DW_CHILDREN_no =0x00, |
|
- DW_CHILDREN_yes =0x01 |
|
+ DW_CHILDREN_no = 0, |
|
+ DW_CHILDREN_yes = 1 |
|
}; |
|
|
|
// Source language names and codes. |
|
@@ -247,20 +262,38 @@ enum DW_LANG |
|
DW_LANG_HP_Assembler = 0x8007 |
|
}; |
|
|
|
+// Range list entry kinds in .debug_rnglists* section. |
|
+ |
|
+enum DW_RLE |
|
+{ |
|
+ DW_RLE_end_of_list = 0x00, |
|
+ DW_RLE_base_addressx = 0x01, |
|
+ DW_RLE_startx_endx = 0x02, |
|
+ DW_RLE_startx_length = 0x03, |
|
+ DW_RLE_offset_pair = 0x04, |
|
+ DW_RLE_base_address = 0x05, |
|
+ DW_RLE_start_end = 0x06, |
|
+ DW_RLE_start_length = 0x07 |
|
+}; |
|
+ |
|
// DWARF section identifiers used in the package format. |
|
// Extensions for Fission. See http://gcc.gnu.org/wiki/DebugFissionDWP. |
|
+// Added (with changes) in DWARF 5. |
|
|
|
enum DW_SECT |
|
{ |
|
- DW_SECT_INFO = 1, |
|
- DW_SECT_TYPES = 2, |
|
- DW_SECT_ABBREV = 3, |
|
- DW_SECT_LINE = 4, |
|
- DW_SECT_LOC = 5, |
|
+ DW_SECT_INFO = 1, |
|
+ DW_SECT_ABBREV = 3, |
|
+ DW_SECT_LINE = 4, |
|
+ DW_SECT_LOCLISTS = 5, |
|
DW_SECT_STR_OFFSETS = 6, |
|
- DW_SECT_MACINFO = 7, |
|
- DW_SECT_MACRO = 8, |
|
- DW_SECT_MAX = DW_SECT_MACRO, |
|
+ DW_SECT_MACINFO = 7, |
|
+ DW_SECT_RNGLISTS = 8, |
|
+ DW_SECT_MAX = DW_SECT_RNGLISTS, |
|
+ // These were used only for the experimental Fission support in DWARF 4. |
|
+ DW_SECT_TYPES = 2, |
|
+ DW_SECT_LOC = 5, |
|
+ DW_SECT_MACRO = 8 |
|
}; |
|
|
|
} // End namespace elfcpp. |
|
diff -rup binutils.orig/gold/dwarf_reader.cc binutils-2.35.2/gold/dwarf_reader.cc |
|
--- binutils.orig/gold/dwarf_reader.cc 2023-04-19 12:23:43.980095113 +0100 |
|
+++ binutils-2.35.2/gold/dwarf_reader.cc 2023-04-19 12:24:08.898077535 +0100 |
|
@@ -26,6 +26,7 @@ |
|
#include <utility> |
|
#include <vector> |
|
|
|
+#include "debug.h" |
|
#include "elfcpp_swap.h" |
|
#include "dwarf.h" |
|
#include "object.h" |
|
@@ -275,6 +276,14 @@ Dwarf_abbrev_table::do_get_abbrev(unsign |
|
uint64_t form = read_unsigned_LEB_128(this->buffer_pos_, &len); |
|
this->buffer_pos_ += len; |
|
|
|
+ // For DW_FORM_implicit_const, read the constant. |
|
+ int64_t implicit_const = 0; |
|
+ if (form == elfcpp::DW_FORM_implicit_const) |
|
+ { |
|
+ implicit_const = read_signed_LEB_128(this->buffer_pos_, &len); |
|
+ this->buffer_pos_ += len; |
|
+ } |
|
+ |
|
// A (0,0) pair terminates the list. |
|
if (attr == 0 && form == 0) |
|
break; |
|
@@ -282,7 +291,7 @@ Dwarf_abbrev_table::do_get_abbrev(unsign |
|
if (attr == elfcpp::DW_AT_sibling) |
|
entry->has_sibling_attribute = true; |
|
|
|
- entry->add_attribute(attr, form); |
|
+ entry->add_attribute(attr, form, implicit_const); |
|
} |
|
|
|
this->store_abbrev(nextcode, entry); |
|
@@ -302,8 +311,16 @@ Dwarf_ranges_table::read_ranges_table( |
|
Relobj* object, |
|
const unsigned char* symtab, |
|
off_t symtab_size, |
|
- unsigned int ranges_shndx) |
|
+ unsigned int ranges_shndx, |
|
+ unsigned int version) |
|
{ |
|
+ const std::string section_name(version < 5 |
|
+ ? ".debug_ranges" |
|
+ : ".debug_rnglists"); |
|
+ const std::string compressed_section_name(version < 5 |
|
+ ? ".zdebug_ranges" |
|
+ : ".zdebug_rnglists"); |
|
+ |
|
// If we've already read this abbrev table, return immediately. |
|
if (this->ranges_shndx_ > 0 |
|
&& this->ranges_shndx_ == ranges_shndx) |
|
@@ -318,7 +335,7 @@ Dwarf_ranges_table::read_ranges_table( |
|
for (unsigned int i = 1; i < object->shnum(); ++i) |
|
{ |
|
std::string name = object->section_name(i); |
|
- if (name == ".debug_ranges" || name == ".zdebug_ranges") |
|
+ if (name == section_name || name == compressed_section_name) |
|
{ |
|
ranges_shndx = i; |
|
this->output_section_offset_ = object->output_section_offset(i); |
|
@@ -393,7 +410,7 @@ Dwarf_ranges_table::read_range_list( |
|
{ |
|
Dwarf_range_list* ranges; |
|
|
|
- if (!this->read_ranges_table(object, symtab, symtab_size, ranges_shndx)) |
|
+ if (!this->read_ranges_table(object, symtab, symtab_size, ranges_shndx, 4)) |
|
return NULL; |
|
|
|
// Correct the offset. For incremental update links, we have a |
|
@@ -459,6 +476,125 @@ Dwarf_ranges_table::read_range_list( |
|
return ranges; |
|
} |
|
|
|
+// Read a DWARF 5 range list from section RANGES_SHNDX at offset RANGES_OFFSET. |
|
+ |
|
+Dwarf_range_list* |
|
+Dwarf_ranges_table::read_range_list_v5( |
|
+ Relobj* object, |
|
+ const unsigned char* symtab, |
|
+ off_t symtab_size, |
|
+ unsigned int addr_size, |
|
+ unsigned int ranges_shndx, |
|
+ off_t offset) |
|
+{ |
|
+ Dwarf_range_list* ranges; |
|
+ |
|
+ if (!this->read_ranges_table(object, symtab, symtab_size, ranges_shndx, 5)) |
|
+ return NULL; |
|
+ |
|
+ ranges = new Dwarf_range_list(); |
|
+ off_t base = 0; |
|
+ unsigned int shndx0 = 0; |
|
+ |
|
+ // Correct the offset. For incremental update links, we have a |
|
+ // relocated offset that is relative to the output section, but |
|
+ // here we need an offset relative to the input section. |
|
+ offset -= this->output_section_offset_; |
|
+ |
|
+ // Read the range list at OFFSET. |
|
+ const unsigned char* prle = this->ranges_buffer_ + offset; |
|
+ while (prle < this->ranges_buffer_end_) |
|
+ { |
|
+ off_t start; |
|
+ off_t end; |
|
+ unsigned int shndx1 = 0; |
|
+ unsigned int shndx2 = 0; |
|
+ size_t len; |
|
+ |
|
+ // Read the entry type. |
|
+ unsigned int rle_type = *prle++; |
|
+ offset += 1; |
|
+ |
|
+ if (rle_type == elfcpp::DW_RLE_end_of_list) |
|
+ break; |
|
+ |
|
+ switch (rle_type) |
|
+ { |
|
+ case elfcpp::DW_RLE_base_address: |
|
+ if (addr_size == 4) |
|
+ base = this->dwinfo_->read_from_pointer<32>(prle); |
|
+ else |
|
+ base = this->dwinfo_->read_from_pointer<64>(prle); |
|
+ if (this->ranges_reloc_mapper_ != NULL) |
|
+ shndx0 = this->lookup_reloc(offset, &base); |
|
+ prle += addr_size; |
|
+ offset += addr_size; |
|
+ break; |
|
+ |
|
+ case elfcpp::DW_RLE_offset_pair: |
|
+ start = read_unsigned_LEB_128(prle, &len); |
|
+ prle += len; |
|
+ offset += len; |
|
+ end = read_unsigned_LEB_128(prle, &len); |
|
+ prle += len; |
|
+ offset += len; |
|
+ if (shndx0 == 0 || object->is_section_included(shndx0)) |
|
+ ranges->add(shndx0, base + start, base + end); |
|
+ break; |
|
+ |
|
+ case elfcpp::DW_RLE_start_end: |
|
+ if (addr_size == 4) |
|
+ { |
|
+ start = this->dwinfo_->read_from_pointer<32>(prle); |
|
+ end = this->dwinfo_->read_from_pointer<32>(prle + 4); |
|
+ } |
|
+ else |
|
+ { |
|
+ start = this->dwinfo_->read_from_pointer<64>(prle); |
|
+ end = this->dwinfo_->read_from_pointer<64>(prle + 8); |
|
+ } |
|
+ if (this->ranges_reloc_mapper_ != NULL) |
|
+ { |
|
+ shndx1 = this->lookup_reloc(offset, &start); |
|
+ shndx2 = this->lookup_reloc(offset + addr_size, &end); |
|
+ if (shndx1 != shndx2) |
|
+ gold_warning(_("%s: DWARF info may be corrupt; offsets in a " |
|
+ "range list entry are in different sections"), |
|
+ object->name().c_str()); |
|
+ } |
|
+ prle += addr_size * 2; |
|
+ offset += addr_size * 2; |
|
+ if (shndx1 == 0 || object->is_section_included(shndx1)) |
|
+ ranges->add(shndx1, start, end); |
|
+ break; |
|
+ |
|
+ case elfcpp::DW_RLE_start_length: |
|
+ if (addr_size == 4) |
|
+ start = this->dwinfo_->read_from_pointer<32>(prle); |
|
+ else |
|
+ start = this->dwinfo_->read_from_pointer<64>(prle); |
|
+ if (this->ranges_reloc_mapper_ != NULL) |
|
+ shndx1 = this->lookup_reloc(offset, &start); |
|
+ prle += addr_size; |
|
+ offset += addr_size; |
|
+ end = start + read_unsigned_LEB_128(prle, &len); |
|
+ prle += len; |
|
+ offset += len; |
|
+ if (shndx1 == 0 || object->is_section_included(shndx1)) |
|
+ ranges->add(shndx1, start, end); |
|
+ break; |
|
+ |
|
+ default: |
|
+ gold_warning(_("%s: DWARF range list contains " |
|
+ "unsupported entry type (%d)"), |
|
+ object->name().c_str(), rle_type); |
|
+ break; |
|
+ } |
|
+ } |
|
+ |
|
+ return ranges; |
|
+} |
|
+ |
|
// Look for a relocation at offset OFF in the range table, |
|
// and return the section index and offset of the target. |
|
|
|
@@ -709,7 +845,13 @@ Dwarf_die::read_attributes() |
|
case elfcpp::DW_FORM_flag_present: |
|
attr_value.val.intval = 1; |
|
break; |
|
+ case elfcpp::DW_FORM_implicit_const: |
|
+ attr_value.val.intval = |
|
+ this->abbrev_code_->attributes[i].implicit_const; |
|
+ break; |
|
case elfcpp::DW_FORM_strp: |
|
+ case elfcpp::DW_FORM_strp_sup: |
|
+ case elfcpp::DW_FORM_line_strp: |
|
{ |
|
off_t str_off; |
|
if (this->dwinfo_->offset_size() == 4) |
|
@@ -722,6 +864,26 @@ Dwarf_die::read_attributes() |
|
attr_value.val.refval = str_off; |
|
break; |
|
} |
|
+ case elfcpp::DW_FORM_strx: |
|
+ case elfcpp::DW_FORM_GNU_str_index: |
|
+ attr_value.val.uintval = read_unsigned_LEB_128(pattr, &len); |
|
+ pattr += len; |
|
+ break; |
|
+ case elfcpp::DW_FORM_strx1: |
|
+ attr_value.val.uintval = *pattr++; |
|
+ break; |
|
+ case elfcpp::DW_FORM_strx2: |
|
+ attr_value.val.uintval = |
|
+ this->dwinfo_->read_from_pointer<16>(&pattr); |
|
+ break; |
|
+ case elfcpp::DW_FORM_strx3: |
|
+ attr_value.val.uintval = |
|
+ this->dwinfo_->read_3bytes_from_pointer(&pattr); |
|
+ break; |
|
+ case elfcpp::DW_FORM_strx4: |
|
+ attr_value.val.uintval = |
|
+ this->dwinfo_->read_from_pointer<32>(&pattr); |
|
+ break; |
|
case elfcpp::DW_FORM_sec_offset: |
|
{ |
|
off_t sec_off; |
|
@@ -747,7 +909,6 @@ Dwarf_die::read_attributes() |
|
this->dwinfo_->lookup_reloc(attr_off, &sec_off); |
|
attr_value.aux.shndx = shndx; |
|
attr_value.val.refval = sec_off; |
|
- ref_form = true; |
|
break; |
|
} |
|
case elfcpp::DW_FORM_ref_addr: |
|
@@ -815,6 +976,7 @@ Dwarf_die::read_attributes() |
|
break; |
|
} |
|
case elfcpp::DW_FORM_ref4: |
|
+ case elfcpp::DW_FORM_ref_sup4: |
|
{ |
|
off_t sec_off; |
|
sec_off = this->dwinfo_->read_from_pointer<32>(&pattr); |
|
@@ -835,11 +997,20 @@ Dwarf_die::read_attributes() |
|
attr_value.val.intval = sec_off; |
|
break; |
|
} |
|
+ case elfcpp::DW_FORM_data16: |
|
+ { |
|
+ // For now, treat this as a 16-byte block. |
|
+ attr_value.val.blockval = pattr; |
|
+ attr_value.aux.blocklen = 16; |
|
+ pattr += 16; |
|
+ break; |
|
+ } |
|
case elfcpp::DW_FORM_ref_sig8: |
|
attr_value.val.uintval = |
|
this->dwinfo_->read_from_pointer<64>(&pattr); |
|
break; |
|
case elfcpp::DW_FORM_ref8: |
|
+ case elfcpp::DW_FORM_ref_sup8: |
|
{ |
|
off_t sec_off; |
|
sec_off = this->dwinfo_->read_from_pointer<64>(&pattr); |
|
@@ -856,11 +1027,29 @@ Dwarf_die::read_attributes() |
|
pattr += len; |
|
break; |
|
case elfcpp::DW_FORM_udata: |
|
+ attr_value.val.uintval = read_unsigned_LEB_128(pattr, &len); |
|
+ pattr += len; |
|
+ break; |
|
+ case elfcpp::DW_FORM_addrx: |
|
case elfcpp::DW_FORM_GNU_addr_index: |
|
- case elfcpp::DW_FORM_GNU_str_index: |
|
attr_value.val.uintval = read_unsigned_LEB_128(pattr, &len); |
|
pattr += len; |
|
break; |
|
+ case elfcpp::DW_FORM_addrx1: |
|
+ attr_value.val.uintval = *pattr++; |
|
+ break; |
|
+ case elfcpp::DW_FORM_addrx2: |
|
+ attr_value.val.uintval = |
|
+ this->dwinfo_->read_from_pointer<16>(&pattr); |
|
+ break; |
|
+ case elfcpp::DW_FORM_addrx3: |
|
+ attr_value.val.uintval = |
|
+ this->dwinfo_->read_3bytes_from_pointer(&pattr); |
|
+ break; |
|
+ case elfcpp::DW_FORM_addrx4: |
|
+ attr_value.val.uintval = |
|
+ this->dwinfo_->read_from_pointer<32>(&pattr); |
|
+ break; |
|
case elfcpp::DW_FORM_sdata: |
|
attr_value.val.intval = read_signed_LEB_128(pattr, &len); |
|
pattr += len; |
|
@@ -870,6 +1059,11 @@ Dwarf_die::read_attributes() |
|
len = strlen(attr_value.val.stringval); |
|
pattr += len + 1; |
|
break; |
|
+ case elfcpp::DW_FORM_loclistx: |
|
+ case elfcpp::DW_FORM_rnglistx: |
|
+ attr_value.val.uintval = read_unsigned_LEB_128(pattr, &len); |
|
+ pattr += len; |
|
+ break; |
|
default: |
|
return false; |
|
} |
|
@@ -954,9 +1148,12 @@ Dwarf_die::skip_attributes() |
|
switch(form) |
|
{ |
|
case elfcpp::DW_FORM_flag_present: |
|
+ case elfcpp::DW_FORM_implicit_const: |
|
break; |
|
case elfcpp::DW_FORM_strp: |
|
case elfcpp::DW_FORM_sec_offset: |
|
+ case elfcpp::DW_FORM_strp_sup: |
|
+ case elfcpp::DW_FORM_line_strp: |
|
pattr += this->dwinfo_->offset_size(); |
|
break; |
|
case elfcpp::DW_FORM_addr: |
|
@@ -993,23 +1190,42 @@ Dwarf_die::skip_attributes() |
|
case elfcpp::DW_FORM_data1: |
|
case elfcpp::DW_FORM_ref1: |
|
case elfcpp::DW_FORM_flag: |
|
+ case elfcpp::DW_FORM_strx1: |
|
+ case elfcpp::DW_FORM_addrx1: |
|
pattr += 1; |
|
break; |
|
case elfcpp::DW_FORM_data2: |
|
case elfcpp::DW_FORM_ref2: |
|
+ case elfcpp::DW_FORM_strx2: |
|
+ case elfcpp::DW_FORM_addrx2: |
|
pattr += 2; |
|
break; |
|
+ case elfcpp::DW_FORM_strx3: |
|
+ case elfcpp::DW_FORM_addrx3: |
|
+ pattr += 3; |
|
+ break; |
|
case elfcpp::DW_FORM_data4: |
|
case elfcpp::DW_FORM_ref4: |
|
+ case elfcpp::DW_FORM_ref_sup4: |
|
+ case elfcpp::DW_FORM_strx4: |
|
+ case elfcpp::DW_FORM_addrx4: |
|
pattr += 4; |
|
break; |
|
case elfcpp::DW_FORM_data8: |
|
case elfcpp::DW_FORM_ref8: |
|
case elfcpp::DW_FORM_ref_sig8: |
|
+ case elfcpp::DW_FORM_ref_sup8: |
|
pattr += 8; |
|
break; |
|
+ case elfcpp::DW_FORM_data16: |
|
+ pattr += 16; |
|
+ break; |
|
case elfcpp::DW_FORM_ref_udata: |
|
case elfcpp::DW_FORM_udata: |
|
+ case elfcpp::DW_FORM_addrx: |
|
+ case elfcpp::DW_FORM_strx: |
|
+ case elfcpp::DW_FORM_loclistx: |
|
+ case elfcpp::DW_FORM_rnglistx: |
|
case elfcpp::DW_FORM_GNU_addr_index: |
|
case elfcpp::DW_FORM_GNU_str_index: |
|
read_unsigned_LEB_128(pattr, &len); |
|
@@ -1313,6 +1529,13 @@ Dwarf_info_reader::do_parse() |
|
elfcpp::Swap_unaligned<16, big_endian>::readval(pinfo); |
|
pinfo += 2; |
|
|
|
+ // DWARF 5: Read the unit type (1 byte) and address size (1 byte). |
|
+ if (this->cu_version_ >= 5) |
|
+ { |
|
+ this->unit_type_ = *pinfo++; |
|
+ this->address_size_ = *pinfo++; |
|
+ } |
|
+ |
|
// Read debug_abbrev_offset (4 or 8 bytes). |
|
if (this->offset_size_ == 4) |
|
abbrev_offset = elfcpp::Swap_unaligned<32, big_endian>::readval(pinfo); |
|
@@ -1333,13 +1556,14 @@ Dwarf_info_reader::do_parse() |
|
} |
|
pinfo += this->offset_size_; |
|
|
|
- // Read address_size (1 byte). |
|
- this->address_size_ = *pinfo++; |
|
+ // DWARF 2-4: Read address_size (1 byte). |
|
+ if (this->cu_version_ < 5) |
|
+ this->address_size_ = *pinfo++; |
|
|
|
// For type units, read the two extra fields. |
|
uint64_t signature = 0; |
|
off_t type_offset = 0; |
|
- if (this->is_type_unit_) |
|
+ if (this->is_type_unit()) |
|
{ |
|
if (!this->check_buffer(pinfo + 8 + this->offset_size_)) |
|
break; |
|
@@ -1369,7 +1593,7 @@ Dwarf_info_reader::do_parse() |
|
if (root_die.tag() != 0) |
|
{ |
|
// Visit the CU or TU. |
|
- if (this->is_type_unit_) |
|
+ if (this->is_type_unit()) |
|
this->visit_type_unit(section_offset + this->cu_offset_, |
|
cu_end - cu_start, type_offset, signature, |
|
&root_die); |
|
@@ -1460,6 +1684,19 @@ Dwarf_info_reader::read_from_pointer(con |
|
return return_value; |
|
} |
|
|
|
+// Read a 3-byte integer. Update SOURCE after read. |
|
+inline typename elfcpp::Valtype_base<32>::Valtype |
|
+Dwarf_info_reader::read_3bytes_from_pointer(const unsigned char** source) |
|
+{ |
|
+ typename elfcpp::Valtype_base<32>::Valtype return_value; |
|
+ if (this->object_->is_big_endian()) |
|
+ return_value = ((*source)[0] << 16) | ((*source)[1] << 8) | (*source)[2]; |
|
+ else |
|
+ return_value = ((*source)[2] << 16) | ((*source)[1] << 8) | (*source)[0]; |
|
+ *source += 3; |
|
+ return return_value; |
|
+} |
|
+ |
|
// Look for a relocation at offset ATTR_OFF in the dwarf info, |
|
// and return the section index and offset of the target. |
|
|
|
@@ -1561,27 +1798,40 @@ Sized_dwarf_line_info<size, big_endian>: |
|
Object* object, |
|
unsigned int read_shndx) |
|
: data_valid_(false), buffer_(NULL), buffer_start_(NULL), |
|
+ str_buffer_(NULL), str_buffer_start_(NULL), |
|
reloc_mapper_(NULL), symtab_buffer_(NULL), directories_(), files_(), |
|
- current_header_index_(-1) |
|
+ current_header_index_(-1), reloc_map_(), line_number_map_() |
|
{ |
|
- unsigned int debug_shndx; |
|
+ unsigned int debug_line_shndx = 0; |
|
+ unsigned int debug_line_str_shndx = 0; |
|
|
|
- for (debug_shndx = 1; debug_shndx < object->shnum(); ++debug_shndx) |
|
+ for (unsigned int i = 1; i < object->shnum(); ++i) |
|
{ |
|
+ section_size_type buffer_size; |
|
+ bool is_new = false; |
|
+ |
|
// FIXME: do this more efficiently: section_name() isn't super-fast |
|
- std::string name = object->section_name(debug_shndx); |
|
+ std::string name = object->section_name(i); |
|
if (name == ".debug_line" || name == ".zdebug_line") |
|
{ |
|
- section_size_type buffer_size; |
|
- bool is_new = false; |
|
- this->buffer_ = object->decompressed_section_contents(debug_shndx, |
|
- &buffer_size, |
|
- &is_new); |
|
+ this->buffer_ = |
|
+ object->decompressed_section_contents(i, &buffer_size, &is_new); |
|
if (is_new) |
|
this->buffer_start_ = this->buffer_; |
|
this->buffer_end_ = this->buffer_ + buffer_size; |
|
- break; |
|
+ debug_line_shndx = i; |
|
} |
|
+ else if (name == ".debug_line_str" || name == ".zdebug_line_str") |
|
+ { |
|
+ this->str_buffer_ = |
|
+ object->decompressed_section_contents(i, &buffer_size, &is_new); |
|
+ if (is_new) |
|
+ this->str_buffer_start_ = this->str_buffer_; |
|
+ this->str_buffer_end_ = this->str_buffer_ + buffer_size; |
|
+ debug_line_str_shndx = i; |
|
+ } |
|
+ if (debug_line_shndx > 0 && debug_line_str_shndx > 0) |
|
+ break; |
|
} |
|
if (this->buffer_ == NULL) |
|
return; |
|
@@ -1594,7 +1844,7 @@ Sized_dwarf_line_info<size, big_endian>: |
|
unsigned int reloc_sh_type = object->section_type(i); |
|
if ((reloc_sh_type == elfcpp::SHT_REL |
|
|| reloc_sh_type == elfcpp::SHT_RELA) |
|
- && object->section_info(i) == debug_shndx) |
|
+ && object->section_info(i) == debug_line_shndx) |
|
{ |
|
reloc_shndx = i; |
|
this->track_relocs_type_ = reloc_sh_type; |
|
@@ -1640,65 +1890,80 @@ Sized_dwarf_line_info<size, big_endian>: |
|
uint32_t initial_length = elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr); |
|
lineptr += 4; |
|
|
|
- // In DWARF2/3, if the initial length is all 1 bits, then the offset |
|
+ // In DWARF, if the initial length is all 1 bits, then the offset |
|
// size is 8 and we need to read the next 8 bytes for the real length. |
|
if (initial_length == 0xffffffff) |
|
{ |
|
- header_.offset_size = 8; |
|
+ this->header_.offset_size = 8; |
|
initial_length = elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr); |
|
lineptr += 8; |
|
} |
|
else |
|
- header_.offset_size = 4; |
|
+ this->header_.offset_size = 4; |
|
|
|
- header_.total_length = initial_length; |
|
+ this->header_.total_length = initial_length; |
|
|
|
- gold_assert(lineptr + header_.total_length <= buffer_end_); |
|
+ this->end_of_unit_ = lineptr + initial_length; |
|
+ gold_assert(this->end_of_unit_ <= buffer_end_); |
|
|
|
- header_.version = elfcpp::Swap_unaligned<16, big_endian>::readval(lineptr); |
|
+ this->header_.version = |
|
+ elfcpp::Swap_unaligned<16, big_endian>::readval(lineptr); |
|
lineptr += 2; |
|
|
|
- // Skip address size and segment selector for DWARF5. |
|
- if (header_.version >= 5) |
|
- lineptr += 2; |
|
- |
|
- if (header_.offset_size == 4) |
|
- header_.prologue_length = elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr); |
|
+ // We can only read versions 2-5 of the DWARF line number table. |
|
+ // For other versions, just skip the entire line number table. |
|
+ if (this->header_.version < 2 || this->header_.version > 5) |
|
+ return this->end_of_unit_; |
|
+ |
|
+ // DWARF 5 only: address size and segment selector. |
|
+ if (this->header_.version >= 5) |
|
+ { |
|
+ this->header_.address_size = *lineptr; |
|
+ // We ignore the segment selector. |
|
+ lineptr += 2; |
|
+ } |
|
+ |
|
+ if (this->header_.offset_size == 4) |
|
+ this->header_.prologue_length = |
|
+ elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr); |
|
else |
|
- header_.prologue_length = elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr); |
|
- lineptr += header_.offset_size; |
|
+ this->header_.prologue_length = |
|
+ elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr); |
|
+ lineptr += this->header_.offset_size; |
|
|
|
- header_.min_insn_length = *lineptr; |
|
+ this->end_of_header_length_ = lineptr; |
|
+ |
|
+ this->header_.min_insn_length = *lineptr; |
|
lineptr += 1; |
|
|
|
- if (header_.version < 4) |
|
- header_.max_ops_per_insn = 1; |
|
+ if (this->header_.version < 4) |
|
+ this->header_.max_ops_per_insn = 1; |
|
else |
|
{ |
|
// DWARF 4 added the maximum_operations_per_instruction field. |
|
- header_.max_ops_per_insn = *lineptr; |
|
+ this->header_.max_ops_per_insn = *lineptr; |
|
lineptr += 1; |
|
// TODO: Add support for values other than 1. |
|
- gold_assert(header_.max_ops_per_insn == 1); |
|
+ gold_assert(this->header_.max_ops_per_insn == 1); |
|
} |
|
|
|
- header_.default_is_stmt = *lineptr; |
|
+ this->header_.default_is_stmt = *lineptr; |
|
lineptr += 1; |
|
|
|
- header_.line_base = *reinterpret_cast<const signed char*>(lineptr); |
|
+ this->header_.line_base = *reinterpret_cast<const signed char*>(lineptr); |
|
lineptr += 1; |
|
|
|
- header_.line_range = *lineptr; |
|
+ this->header_.line_range = *lineptr; |
|
lineptr += 1; |
|
|
|
- header_.opcode_base = *lineptr; |
|
+ this->header_.opcode_base = *lineptr; |
|
lineptr += 1; |
|
|
|
- header_.std_opcode_lengths.resize(header_.opcode_base + 1); |
|
- header_.std_opcode_lengths[0] = 0; |
|
- for (int i = 1; i < header_.opcode_base; i++) |
|
+ this->header_.std_opcode_lengths.resize(this->header_.opcode_base + 1); |
|
+ this->header_.std_opcode_lengths[0] = 0; |
|
+ for (int i = 1; i < this->header_.opcode_base; i++) |
|
{ |
|
- header_.std_opcode_lengths[i] = *lineptr; |
|
+ this->header_.std_opcode_lengths[i] = *lineptr; |
|
lineptr += 1; |
|
} |
|
|
|
@@ -1707,10 +1972,11 @@ Sized_dwarf_line_info<size, big_endian>: |
|
|
|
// The header for a debug_line section is mildly complicated, because |
|
// the line info is very tightly encoded. |
|
+// This routine is for DWARF versions 2, 3, and 4. |
|
|
|
template<int size, bool big_endian> |
|
const unsigned char* |
|
-Sized_dwarf_line_info<size, big_endian>::read_header_tables( |
|
+Sized_dwarf_line_info<size, big_endian>::read_header_tables_v2( |
|
const unsigned char* lineptr) |
|
{ |
|
++this->current_header_index_; |
|
@@ -1775,6 +2041,169 @@ Sized_dwarf_line_info<size, big_endian>: |
|
return lineptr; |
|
} |
|
|
|
+// This routine is for DWARF version 5. |
|
+ |
|
+template<int size, bool big_endian> |
|
+const unsigned char* |
|
+Sized_dwarf_line_info<size, big_endian>::read_header_tables_v5( |
|
+ const unsigned char* lineptr) |
|
+{ |
|
+ size_t len; |
|
+ |
|
+ ++this->current_header_index_; |
|
+ |
|
+ gold_assert(static_cast<int>(this->directories_.size()) |
|
+ == this->current_header_index_); |
|
+ gold_assert(static_cast<int>(this->files_.size()) |
|
+ == this->current_header_index_); |
|
+ |
|
+ // Read the directory list. |
|
+ unsigned int format_count = *lineptr; |
|
+ lineptr += 1; |
|
+ |
|
+ unsigned int *types = new unsigned int[format_count]; |
|
+ unsigned int *forms = new unsigned int[format_count]; |
|
+ |
|
+ for (unsigned int i = 0; i < format_count; i++) |
|
+ { |
|
+ types[i] = read_unsigned_LEB_128(lineptr, &len); |
|
+ lineptr += len; |
|
+ forms[i] = read_unsigned_LEB_128(lineptr, &len); |
|
+ lineptr += len; |
|
+ } |
|
+ |
|
+ uint64_t entry_count = read_unsigned_LEB_128(lineptr, &len); |
|
+ lineptr += len; |
|
+ this->directories_.push_back(std::vector<std::string>(0)); |
|
+ std::vector<std::string>& dir_list = this->directories_.back(); |
|
+ |
|
+ for (unsigned int j = 0; j < entry_count; j++) |
|
+ { |
|
+ std::string dirname; |
|
+ |
|
+ for (unsigned int i = 0; i < format_count; i++) |
|
+ { |
|
+ if (types[i] == elfcpp::DW_LNCT_path) |
|
+ { |
|
+ if (forms[i] == elfcpp::DW_FORM_string) |
|
+ { |
|
+ dirname = reinterpret_cast<const char*>(lineptr); |
|
+ lineptr += dirname.size() + 1; |
|
+ } |
|
+ else if (forms[i] == elfcpp::DW_FORM_line_strp) |
|
+ { |
|
+ uint64_t offset; |
|
+ if (this->header_.offset_size == 4) |
|
+ offset = |
|
+ elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr); |
|
+ else |
|
+ offset = |
|
+ elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr); |
|
+ typename Reloc_map::const_iterator it |
|
+ = this->reloc_map_.find(lineptr - this->buffer_); |
|
+ if (it != reloc_map_.end()) |
|
+ { |
|
+ if (this->track_relocs_type_ == elfcpp::SHT_RELA) |
|
+ offset = 0; |
|
+ offset += it->second.second; |
|
+ } |
|
+ lineptr += this->header_.offset_size; |
|
+ dirname = reinterpret_cast<const char*>(this->str_buffer_ |
|
+ + offset); |
|
+ } |
|
+ else |
|
+ return lineptr; |
|
+ } |
|
+ else |
|
+ return lineptr; |
|
+ } |
|
+ dir_list.push_back(dirname); |
|
+ } |
|
+ |
|
+ delete[] types; |
|
+ delete[] forms; |
|
+ |
|
+ // Read the filenames list. |
|
+ format_count = *lineptr; |
|
+ lineptr += 1; |
|
+ |
|
+ types = new unsigned int[format_count]; |
|
+ forms = new unsigned int[format_count]; |
|
+ |
|
+ for (unsigned int i = 0; i < format_count; i++) |
|
+ { |
|
+ types[i] = read_unsigned_LEB_128(lineptr, &len); |
|
+ lineptr += len; |
|
+ forms[i] = read_unsigned_LEB_128(lineptr, &len); |
|
+ lineptr += len; |
|
+ } |
|
+ |
|
+ entry_count = read_unsigned_LEB_128(lineptr, &len); |
|
+ lineptr += len; |
|
+ this->files_.push_back( |
|
+ std::vector<std::pair<int, std::string> >(0)); |
|
+ std::vector<std::pair<int, std::string> >& file_list = this->files_.back(); |
|
+ |
|
+ for (unsigned int j = 0; j < entry_count; j++) |
|
+ { |
|
+ const char* path = NULL; |
|
+ int dirindex = 0; |
|
+ |
|
+ for (unsigned int i = 0; i < format_count; i++) |
|
+ { |
|
+ if (types[i] == elfcpp::DW_LNCT_path) |
|
+ { |
|
+ if (forms[i] == elfcpp::DW_FORM_string) |
|
+ { |
|
+ path = reinterpret_cast<const char*>(lineptr); |
|
+ lineptr += strlen(path) + 1; |
|
+ } |
|
+ else if (forms[i] == elfcpp::DW_FORM_line_strp) |
|
+ { |
|
+ uint64_t offset; |
|
+ if (this->header_.offset_size == 4) |
|
+ offset = elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr); |
|
+ else |
|
+ offset = elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr); |
|
+ typename Reloc_map::const_iterator it |
|
+ = this->reloc_map_.find(lineptr - this->buffer_); |
|
+ if (it != reloc_map_.end()) |
|
+ { |
|
+ if (this->track_relocs_type_ == elfcpp::SHT_RELA) |
|
+ offset = 0; |
|
+ offset += it->second.second; |
|
+ } |
|
+ lineptr += this->header_.offset_size; |
|
+ path = reinterpret_cast<const char*>(this->str_buffer_ |
|
+ + offset); |
|
+ } |
|
+ else |
|
+ return lineptr; |
|
+ } |
|
+ else if (types[i] == elfcpp::DW_LNCT_directory_index) |
|
+ { |
|
+ if (forms[i] == elfcpp::DW_FORM_udata) |
|
+ { |
|
+ dirindex = read_unsigned_LEB_128(lineptr, &len); |
|
+ lineptr += len; |
|
+ } |
|
+ else |
|
+ return lineptr; |
|
+ } |
|
+ else |
|
+ return lineptr; |
|
+ } |
|
+ gold_debug(DEBUG_LOCATION, "File %3d: %s", |
|
+ static_cast<int>(file_list.size()), path); |
|
+ file_list.push_back(std::make_pair(dirindex, path)); |
|
+ } |
|
+ |
|
+ delete[] types; |
|
+ delete[] forms; |
|
+ |
|
+ return lineptr; |
|
+} |
|
+ |
|
// Process a single opcode in the .debug.line structure. |
|
|
|
template<int size, bool big_endian> |
|
@@ -1790,15 +2219,15 @@ Sized_dwarf_line_info<size, big_endian>: |
|
|
|
// If the opcode is great than the opcode_base, it is a special |
|
// opcode. Most line programs consist mainly of special opcodes. |
|
- if (opcode >= header_.opcode_base) |
|
+ if (opcode >= this->header_.opcode_base) |
|
{ |
|
- opcode -= header_.opcode_base; |
|
- const int advance_address = ((opcode / header_.line_range) |
|
- * header_.min_insn_length); |
|
+ opcode -= this->header_.opcode_base; |
|
+ const int advance_address = ((opcode / this->header_.line_range) |
|
+ * this->header_.min_insn_length); |
|
lsm->address += advance_address; |
|
|
|
- const int advance_line = ((opcode % header_.line_range) |
|
- + header_.line_base); |
|
+ const int advance_line = ((opcode % this->header_.line_range) |
|
+ + this->header_.line_base); |
|
lsm->line_num += advance_line; |
|
lsm->basic_block = true; |
|
*len = oplen; |
|
@@ -1818,13 +2247,13 @@ Sized_dwarf_line_info<size, big_endian>: |
|
const uint64_t advance_address |
|
= read_unsigned_LEB_128(start, &templen); |
|
oplen += templen; |
|
- lsm->address += header_.min_insn_length * advance_address; |
|
+ lsm->address += this->header_.min_insn_length * advance_address; |
|
} |
|
break; |
|
|
|
case elfcpp::DW_LNS_advance_line: |
|
{ |
|
- const uint64_t advance_line = read_signed_LEB_128(start, &templen); |
|
+ const int64_t advance_line = read_signed_LEB_128(start, &templen); |
|
oplen += templen; |
|
lsm->line_num += advance_line; |
|
} |
|
@@ -1865,9 +2294,9 @@ Sized_dwarf_line_info<size, big_endian>: |
|
|
|
case elfcpp::DW_LNS_const_add_pc: |
|
{ |
|
- const int advance_address = (header_.min_insn_length |
|
- * ((255 - header_.opcode_base) |
|
- / header_.line_range)); |
|
+ const int advance_address = (this->header_.min_insn_length |
|
+ * ((255 - this->header_.opcode_base) |
|
+ / this->header_.line_range)); |
|
lsm->address += advance_address; |
|
} |
|
break; |
|
@@ -1950,7 +2379,7 @@ Sized_dwarf_line_info<size, big_endian>: |
|
default: |
|
{ |
|
// Ignore unknown opcode silently |
|
- for (int i = 0; i < header_.std_opcode_lengths[opcode]; i++) |
|
+ for (int i = 0; i < this->header_.std_opcode_lengths[opcode]; i++) |
|
{ |
|
size_t templen; |
|
read_unsigned_LEB_128(start, &templen); |
|
@@ -1970,28 +2399,24 @@ Sized_dwarf_line_info<size, big_endian>: |
|
template<int size, bool big_endian> |
|
unsigned const char* |
|
Sized_dwarf_line_info<size, big_endian>::read_lines(unsigned const char* lineptr, |
|
+ unsigned const char* endptr, |
|
unsigned int shndx) |
|
{ |
|
struct LineStateMachine lsm; |
|
|
|
- // LENGTHSTART is the place the length field is based on. It is the |
|
- // point in the header after the initial length field. |
|
- const unsigned char* lengthstart = buffer_; |
|
- |
|
- // In 64 bit dwarf, the initial length is 12 bytes, because of the |
|
- // 0xffffffff at the start. |
|
- if (header_.offset_size == 8) |
|
- lengthstart += 12; |
|
- else |
|
- lengthstart += 4; |
|
- |
|
- while (lineptr < lengthstart + header_.total_length) |
|
+ while (lineptr < endptr) |
|
{ |
|
- ResetLineStateMachine(&lsm, header_.default_is_stmt); |
|
+ ResetLineStateMachine(&lsm, this->header_.default_is_stmt); |
|
while (!lsm.end_sequence) |
|
{ |
|
size_t oplength; |
|
+ |
|
+ if (lineptr >= endptr) |
|
+ break; |
|
+ |
|
bool add_line = this->process_one_opcode(lineptr, &lsm, &oplength); |
|
+ lineptr += oplength; |
|
+ |
|
if (add_line |
|
&& (shndx == -1U || lsm.shndx == -1U || shndx == lsm.shndx)) |
|
{ |
|
@@ -2012,11 +2437,10 @@ Sized_dwarf_line_info<size, big_endian>: |
|
map.back().last_line_for_offset = false; |
|
map.push_back(entry); |
|
} |
|
- lineptr += oplength; |
|
} |
|
} |
|
|
|
- return lengthstart + header_.total_length; |
|
+ return endptr; |
|
} |
|
|
|
// Read the relocations into a Reloc_map. |
|
@@ -2057,9 +2481,17 @@ Sized_dwarf_line_info<size, big_endian>: |
|
{ |
|
const unsigned char* lineptr = this->buffer_; |
|
lineptr = this->read_header_prolog(lineptr); |
|
- lineptr = this->read_header_tables(lineptr); |
|
- lineptr = this->read_lines(lineptr, shndx); |
|
- this->buffer_ = lineptr; |
|
+ if (this->header_.version >= 2 && this->header_.version <= 4) |
|
+ { |
|
+ lineptr = this->read_header_tables_v2(lineptr); |
|
+ lineptr = this->read_lines(lineptr, this->end_of_unit_, shndx); |
|
+ } |
|
+ else if (this->header_.version == 5) |
|
+ { |
|
+ lineptr = this->read_header_tables_v5(lineptr); |
|
+ lineptr = this->read_lines(lineptr, this->end_of_unit_, shndx); |
|
+ } |
|
+ this->buffer_ = this->end_of_unit_; |
|
} |
|
|
|
// Sort the lines numbers, so addr2line can use binary search. |
|
@@ -2215,6 +2647,9 @@ Sized_dwarf_line_info<size, big_endian>: |
|
off_t offset, |
|
std::vector<std::string>* other_lines) |
|
{ |
|
+ gold_debug(DEBUG_LOCATION, "do_addr2line: shndx %u offset %08x", |
|
+ shndx, static_cast<int>(offset)); |
|
+ |
|
if (this->data_valid_ == false) |
|
return ""; |
|
|
|
diff -rup binutils.orig/gold/dwarf_reader.h binutils-2.35.2/gold/dwarf_reader.h |
|
--- binutils.orig/gold/dwarf_reader.h 2023-04-19 12:23:43.990095106 +0100 |
|
+++ binutils-2.35.2/gold/dwarf_reader.h 2023-04-19 12:24:05.282080087 +0100 |
|
@@ -173,11 +173,12 @@ class Dwarf_abbrev_table |
|
// An attribute list entry. |
|
struct Attribute |
|
{ |
|
- Attribute(unsigned int a, unsigned int f) |
|
- : attr(a), form(f) |
|
+ Attribute(unsigned int a, unsigned int f, int c) |
|
+ : attr(a), form(f), implicit_const(c) |
|
{ } |
|
unsigned int attr; |
|
unsigned int form; |
|
+ int implicit_const; |
|
}; |
|
|
|
// An abbrev code entry. |
|
@@ -190,9 +191,9 @@ class Dwarf_abbrev_table |
|
} |
|
|
|
void |
|
- add_attribute(unsigned int attr, unsigned int form) |
|
+ add_attribute(unsigned int attr, unsigned int form, int implicit_const) |
|
{ |
|
- this->attributes.push_back(Attribute(attr, form)); |
|
+ this->attributes.push_back(Attribute(attr, form, implicit_const)); |
|
} |
|
|
|
// The DWARF tag. |
|
@@ -349,14 +350,15 @@ class Dwarf_ranges_table |
|
delete this->ranges_reloc_mapper_; |
|
} |
|
|
|
- // Read the ranges table from an object file. |
|
+ // Fetch the contents of the ranges table from an object file. |
|
bool |
|
read_ranges_table(Relobj* object, |
|
const unsigned char* symtab, |
|
off_t symtab_size, |
|
- unsigned int ranges_shndx); |
|
+ unsigned int ranges_shndx, |
|
+ unsigned int version); |
|
|
|
- // Read the range table from an object file. |
|
+ // Read the DWARF 2/3/4 range table. |
|
Dwarf_range_list* |
|
read_range_list(Relobj* object, |
|
const unsigned char* symtab, |
|
@@ -365,6 +367,15 @@ class Dwarf_ranges_table |
|
unsigned int ranges_shndx, |
|
off_t ranges_offset); |
|
|
|
+ // Read the DWARF 5 rnglists table. |
|
+ Dwarf_range_list* |
|
+ read_range_list_v5(Relobj* object, |
|
+ const unsigned char* symtab, |
|
+ off_t symtab_size, |
|
+ unsigned int address_size, |
|
+ unsigned int ranges_shndx, |
|
+ off_t ranges_offset); |
|
+ |
|
// Look for a relocation at offset OFF in the range table, |
|
// and return the section index and offset of the target. |
|
unsigned int |
|
@@ -490,8 +501,6 @@ class Dwarf_die |
|
unsigned int shndx; |
|
// Block length for block forms. |
|
unsigned int blocklen; |
|
- // Attribute offset for DW_FORM_strp. |
|
- unsigned int attr_off; |
|
} aux; |
|
}; |
|
|
|
@@ -684,6 +693,10 @@ class Dwarf_die |
|
// calls the various visit_xxx() methods for each header. Clients |
|
// should derive a new class from this one and implement the |
|
// visit_compilation_unit() and visit_type_unit() functions. |
|
+// IS_TYPE_UNIT is true if we are reading from a .debug_types section, |
|
+// which is used only in DWARF 4. For DWARF 5, it will be false, |
|
+// and we will determine whether it's a type init when we parse the |
|
+// header. |
|
|
|
class Dwarf_info_reader |
|
{ |
|
@@ -695,7 +708,7 @@ class Dwarf_info_reader |
|
unsigned int shndx, |
|
unsigned int reloc_shndx, |
|
unsigned int reloc_type) |
|
- : is_type_unit_(is_type_unit), object_(object), symtab_(symtab), |
|
+ : object_(object), symtab_(symtab), |
|
symtab_size_(symtab_size), shndx_(shndx), reloc_shndx_(reloc_shndx), |
|
reloc_type_(reloc_type), abbrev_shndx_(0), string_shndx_(0), |
|
buffer_(NULL), buffer_end_(NULL), cu_offset_(0), cu_length_(0), |
|
@@ -703,7 +716,12 @@ class Dwarf_info_reader |
|
abbrev_table_(), ranges_table_(this), |
|
reloc_mapper_(NULL), string_buffer_(NULL), string_buffer_end_(NULL), |
|
owns_string_buffer_(false), string_output_section_offset_(0) |
|
- { } |
|
+ { |
|
+ // For DWARF 4, we infer the unit type from the section name. |
|
+ // For DWARF 5, we will read this from the unit header. |
|
+ this->unit_type_ = |
|
+ (is_type_unit ? elfcpp::DW_UT_type : elfcpp::DW_UT_compile); |
|
+ } |
|
|
|
virtual |
|
~Dwarf_info_reader() |
|
@@ -714,6 +732,13 @@ class Dwarf_info_reader |
|
delete[] this->string_buffer_; |
|
} |
|
|
|
+ bool |
|
+ is_type_unit() const |
|
+ { |
|
+ return (this->unit_type_ == elfcpp::DW_UT_type |
|
+ || this->unit_type_ == elfcpp::DW_UT_split_type); |
|
+ } |
|
+ |
|
// Begin parsing the debug info. This calls visit_compilation_unit() |
|
// or visit_type_unit() for each compilation or type unit found in the |
|
// section, and visit_die() for each top-level DIE. |
|
@@ -745,6 +770,9 @@ class Dwarf_info_reader |
|
inline typename elfcpp::Valtype_base<valsize>::Valtype |
|
read_from_pointer(const unsigned char** source); |
|
|
|
+ inline typename elfcpp::Valtype_base<32>::Valtype |
|
+ read_3bytes_from_pointer(const unsigned char** source); |
|
+ |
|
// Look for a relocation at offset ATTR_OFF in the dwarf info, |
|
// and return the section index and offset of the target. |
|
unsigned int |
|
@@ -818,12 +846,20 @@ class Dwarf_info_reader |
|
Dwarf_range_list* |
|
read_range_list(unsigned int ranges_shndx, off_t ranges_offset) |
|
{ |
|
- return this->ranges_table_.read_range_list(this->object_, |
|
- this->symtab_, |
|
- this->symtab_size_, |
|
- this->address_size_, |
|
- ranges_shndx, |
|
- ranges_offset); |
|
+ if (this->cu_version_ < 5) |
|
+ return this->ranges_table_.read_range_list(this->object_, |
|
+ this->symtab_, |
|
+ this->symtab_size_, |
|
+ this->address_size_, |
|
+ ranges_shndx, |
|
+ ranges_offset); |
|
+ else |
|
+ return this->ranges_table_.read_range_list_v5(this->object_, |
|
+ this->symtab_, |
|
+ this->symtab_size_, |
|
+ this->address_size_, |
|
+ ranges_shndx, |
|
+ ranges_offset); |
|
} |
|
|
|
// Return the object. |
|
@@ -873,8 +909,8 @@ class Dwarf_info_reader |
|
bool |
|
do_read_string_table(unsigned int string_shndx); |
|
|
|
- // True if this is a type unit; false for a compilation unit. |
|
- bool is_type_unit_; |
|
+ // The unit type (DW_UT_xxx). |
|
+ unsigned int unit_type_; |
|
// The object containing the .debug_info or .debug_types input section. |
|
Relobj* object_; |
|
// The ELF symbol table. |
|
@@ -1008,6 +1044,8 @@ class Sized_dwarf_line_info : public Dwa |
|
{ |
|
if (this->buffer_start_ != NULL) |
|
delete[] this->buffer_start_; |
|
+ if (this->str_buffer_start_ != NULL) |
|
+ delete[] this->str_buffer_start_; |
|
} |
|
|
|
private: |
|
@@ -1030,19 +1068,23 @@ class Sized_dwarf_line_info : public Dwa |
|
void |
|
read_relocs(); |
|
|
|
- // Reads the DWARF2/3 header for this line info. Each takes as input |
|
+ // Reads the DWARF header for this line info. Each takes as input |
|
// a starting buffer position, and returns the ending position. |
|
const unsigned char* |
|
read_header_prolog(const unsigned char* lineptr); |
|
|
|
const unsigned char* |
|
- read_header_tables(const unsigned char* lineptr); |
|
+ read_header_tables_v2(const unsigned char* lineptr); |
|
+ |
|
+ const unsigned char* |
|
+ read_header_tables_v5(const unsigned char* lineptr); |
|
|
|
- // Reads the DWARF2/3 line information. If shndx is non-negative, |
|
+ // Reads the DWARF line information. If shndx is non-negative, |
|
// discard all line information that doesn't pertain to the given |
|
// section. |
|
const unsigned char* |
|
- read_lines(const unsigned char* lineptr, unsigned int shndx); |
|
+ read_lines(const unsigned char* lineptr, const unsigned char* endptr, |
|
+ unsigned int shndx); |
|
|
|
// Process a single line info opcode at START using the state |
|
// machine at LSM. Return true if we should define a line using the |
|
@@ -1069,6 +1111,7 @@ class Sized_dwarf_line_info : public Dwa |
|
{ |
|
off_t total_length; |
|
int version; |
|
+ int address_size; |
|
off_t prologue_length; |
|
int min_insn_length; // insn stands for instruction |
|
int max_ops_per_insn; // Added in DWARF-4. |
|
@@ -1089,6 +1132,20 @@ class Sized_dwarf_line_info : public Dwa |
|
// of the buffer. |
|
const unsigned char* buffer_start_; |
|
|
|
+ // str_buffer is the buffer for the line table strings. |
|
+ const unsigned char* str_buffer_; |
|
+ const unsigned char* str_buffer_end_; |
|
+ // If the buffer was allocated temporarily, and therefore must be |
|
+ // deallocated in the dtor, this contains a pointer to the start |
|
+ // of the buffer. |
|
+ const unsigned char* str_buffer_start_; |
|
+ |
|
+ // Pointer to the end of the header_length field (aka prologue_length). |
|
+ const unsigned char* end_of_header_length_; |
|
+ |
|
+ // Pointer to the end of the current compilation unit. |
|
+ const unsigned char* end_of_unit_; |
|
+ |
|
// This has relocations that point into buffer. |
|
Sized_elf_reloc_mapper<size, big_endian>* reloc_mapper_; |
|
// The type of the reloc section in track_relocs_--SHT_REL or SHT_RELA.
|
|
|