FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add DWARF 5 support in gold.

Browse source 
elfcpp/
	PR gold/27246
	* dwarf.h (enum DW_LNCT): Add line number table content type codes.
	(enum DW_LINE_OPS): Reformat.
	(enum DW_LINE_EXTENDED_OPS): Reformat.
	(enum DW_CHILDREN): Reformat.
	(enum DW_RLE): Add range list entry types.
	(enum DW_SECT): Update values for DWARF 5.

gold/
	PR gold/27246
	* dwarf_reader.cc (Dwarf_abbrev_table::do_get_abbrev): Handle
	DW_FORM_implicit_const.
	(Dwarf_ranges_table::read_ranges_table): Add version parameter;
	Adjust all callers.  Look for .debug_rnglists section if DWARF 5.
	(Dwarf_ranges_table::read_range_list_v5): New method.
	(Dwarf_die::read_attributes): Handle new DWARF 5 DW_FORM codes.
	(Dwarf_die::skip_attributes): Likewise.
	(Dwarf_info_reader::do_parse): Support DWARF 5 unit header format.
	(Dwarf_info_reader::read_3bytes_from_pointer): New method.
	(Sized_dwarf_line_info::Sized_dwarf_line_info): Initialize
	str_buffer_, str_buffer_start, reloc_map_, line_number_map_.
	Look for .debug_line_str section.
	(Sized_dwarf_line_info::read_header_prolog): Support DWARF 5 prolog.
	(Sized_dwarf_line_info::read_header_tables): Rename to...
	(Sized_dwarf_line_info::read_header_tables_v2): ... this.
	(Sized_dwarf_line_info::read_header_tables_v5): New method.
	(Sized_dwarf_line_info::process_one_opcode): Insert missing "this->".
	Change advance_line to signed int64_t.
	(Sized_dwarf_line_info::read_lines): Add endptr parameter; adjust
	callers.  Insert missing "this->".
	(Sized_dwarf_line_info::read_line_mappings): Support DWARF 5.
	(Sized_dwarf_line_info::do_addr2line): Add debug code.
	* dwarf_reader.h (Dwarf_abbrev_table::Attribute): Add implicit_const
	field. Adjust constructor.
	(Dwarf_abbrev_table::add_sttribute): Add implicit_const parameter.
	(Dwarf_ranges_table::read_ranges_table): Add version parameter.
	(Dwarf_ranges_table::read_range_list_v5): New method.
	(Dwarf_die): Remove unused attr_off field.
	(Dwarf_info_reader::Dwarf_info_reader): Initialize unit_type_ field.
	(Dwarf_info_reader::is_type_unit): New method.
	(Dwarf_info_reader::read_3bytes_from_pointer): New method.
	(Dwarf_info_reader::read_range_list): Call read_range_list_v5 for
	DWARF 5 range lists.
	(Dwarf_info_reader::is_type_unit_): Remove.
	(Dwarf_info_reader::unit_type_): New field.
	(Sized_dwarf_line_info::~Sized_dwarf_line_info): Delete
	str_buffer_start_.
	(Sized_dwarf_line_info::read_header_tables): Rename to...
	(Sized_dwarf_line_info::read_header_tables_v2): ... this.
	(Sized_dwarf_line_info::read_header_tables_v5): New method.
	(Sized_dwarf_line_info::read_lines): Add endptr parameter.
	(Sized_dwarf_line_info::Dwarf_line_infoHeader): Add address_size field.
	(Sized_dwarf_line_info::str_buffer_): New field.
	(Sized_dwarf_line_info::str_buffer_end_): New field.
	(Sized_dwarf_line_info::str_buffer_start_): New field.
	(Sized_dwarf_line_info::end_of_header_length_): New field.
	(Sized_dwarf_line_info::end_of_unit_): New field.
This commit is contained in:
Cary Coutant 2021-03-17 21:31:15 -07:00
parent e0d6d27406
commit 5cde809b7b
5 changed files with 716 additions and 130 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
elfcpp/ChangeLog
View file

@ -1,3 +1,13 @@
2021-03-19 Cary Coutant <ccoutant@gmail.com>
PR gold/27246
* dwarf.h (enum DW_LNCT): Add line number table content type codes.
(enum DW_LINE_OPS): Reformat.
(enum DW_LINE_EXTENDED_OPS): Reformat.
(enum DW_CHILDREN): Reformat.
(enum DW_RLE): Add range list entry types.
(enum DW_SECT): Update values for DWARF 5.
2021-01-09 Nick Clifton <nickc@redhat.com>
* 2.36 release branch crated.

89
elfcpp/dwarf.h
View file

@ -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.

51
gold/ChangeLog
View file

@ -1,3 +1,54 @@
2021-03-19 Cary Coutant <ccoutant@gmail.com>
PR gold/27246
* dwarf_reader.cc (Dwarf_abbrev_table::do_get_abbrev): Handle
DW_FORM_implicit_const.
(Dwarf_ranges_table::read_ranges_table): Add version parameter;
Adjust all callers. Look for .debug_rnglists section if DWARF 5.
(Dwarf_ranges_table::read_range_list_v5): New method.
(Dwarf_die::read_attributes): Handle new DWARF 5 DW_FORM codes.
(Dwarf_die::skip_attributes): Likewise.
(Dwarf_info_reader::do_parse): Support DWARF 5 unit header format.
(Dwarf_info_reader::read_3bytes_from_pointer): New method.
(Sized_dwarf_line_info::Sized_dwarf_line_info): Initialize
str_buffer_, str_buffer_start, reloc_map_, line_number_map_.
Look for .debug_line_str section.
(Sized_dwarf_line_info::read_header_prolog): Support DWARF 5 prolog.
(Sized_dwarf_line_info::read_header_tables): Rename to...
(Sized_dwarf_line_info::read_header_tables_v2): ... this.
(Sized_dwarf_line_info::read_header_tables_v5): New method.
(Sized_dwarf_line_info::process_one_opcode): Insert missing "this->".
Change advance_line to signed int64_t.
(Sized_dwarf_line_info::read_lines): Add endptr parameter; adjust
callers. Insert missing "this->".
(Sized_dwarf_line_info::read_line_mappings): Support DWARF 5.
(Sized_dwarf_line_info::do_addr2line): Add debug code.
* dwarf_reader.h (Dwarf_abbrev_table::Attribute): Add implicit_const
field. Adjust constructor.
(Dwarf_abbrev_table::add_sttribute): Add implicit_const parameter.
(Dwarf_ranges_table::read_ranges_table): Add version parameter.
(Dwarf_ranges_table::read_range_list_v5): New method.
(Dwarf_die): Remove unused attr_off field.
(Dwarf_info_reader::Dwarf_info_reader): Initialize unit_type_ field.
(Dwarf_info_reader::is_type_unit): New method.
(Dwarf_info_reader::read_3bytes_from_pointer): New method.
(Dwarf_info_reader::read_range_list): Call read_range_list_v5 for
DWARF 5 range lists.
(Dwarf_info_reader::is_type_unit_): Remove.
(Dwarf_info_reader::unit_type_): New field.
(Sized_dwarf_line_info::~Sized_dwarf_line_info): Delete
str_buffer_start_.
(Sized_dwarf_line_info::read_header_tables): Rename to...
(Sized_dwarf_line_info::read_header_tables_v2): ... this.
(Sized_dwarf_line_info::read_header_tables_v5): New method.
(Sized_dwarf_line_info::read_lines): Add endptr parameter.
(Sized_dwarf_line_info::Dwarf_line_infoHeader): Add address_size field.
(Sized_dwarf_line_info::str_buffer_): New field.
(Sized_dwarf_line_info::str_buffer_end_): New field.
(Sized_dwarf_line_info::str_buffer_start_): New field.
(Sized_dwarf_line_info::end_of_header_length_): New field.
(Sized_dwarf_line_info::end_of_unit_): New field.
2021-01-28 H.J. Lu <hongjiu.lu@intel.com>
PR gold/27246

593
gold/dwarf_reader.cc
View file

@ -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(unsigned int code)
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(unsigned int code)
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:
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_addrx:
case elfcpp::DW_FORM_GNU_addr_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(const unsigned char** source)
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>::Sized_dwarf_line_info(
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>::Sized_dwarf_line_info(
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>::read_header_prolog(
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;
// 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_;
if (header_.offset_size == 4)
header_.prologue_length = elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr);
// 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>::read_header_prolog(
// 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>::read_header_tables(
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>::process_one_opcode(
// 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>::process_one_opcode(
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>::process_one_opcode(
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>::process_one_opcode(
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>::process_one_opcode(
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>::read_lines(unsigned const char* lineptr
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>::read_line_mappings(unsigned int shndx)
{
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>::do_addr2line(
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 "";

103
gold/dwarf_reader.h
View file

@ -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 Dwarf_line_info
{
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 Dwarf_line_info
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);
// Reads the DWARF2/3 line information. If shndx is non-negative,
const unsigned char*
read_header_tables_v5(const unsigned char* lineptr);
// 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 Dwarf_line_info
{
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 Dwarf_line_info
// 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.