X-Git-Url: http://drtracing.org/?a=blobdiff_plain;ds=sidebyside;f=bfd%2Fdwarf2.c;h=3cd2f7d7d46b39a4b56c1ec5a130f0e273b3d96b;hb=4ccf1e317a7df0e94f1c5f2adc52c4c92b937e65;hp=1eae5e1b732f486a923678736b6aed47c855c93c;hpb=8af6b354b46907fab331b3cba5a812f97c732c88;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/dwarf2.c b/bfd/dwarf2.c index 1eae5e1b73..3cd2f7d7d4 100644 --- a/bfd/dwarf2.c +++ b/bfd/dwarf2.c @@ -45,6 +45,7 @@ struct line_head unsigned short version; bfd_vma prologue_length; unsigned char minimum_instruction_length; + unsigned char maximum_ops_per_insn; unsigned char default_is_stmt; int line_base; unsigned char line_range; @@ -274,6 +275,62 @@ struct attr_abbrev enum dwarf_form form; }; +/* Map of uncompressed DWARF debug section name to compressed one. It + is terminated by NULL uncompressed_name. */ + +const struct dwarf_debug_section dwarf_debug_sections[] = +{ + { ".debug_abbrev", ".zdebug_abbrev" }, + { ".debug_aranges", ".zdebug_aranges" }, + { ".debug_frame", ".zdebug_frame" }, + { ".debug_info", ".zdebug_info" }, + { ".debug_line", ".zdebug_line" }, + { ".debug_loc", ".zdebug_loc" }, + { ".debug_macinfo", ".zdebug_macinfo" }, + { ".debug_macro", ".zdebug_macro" }, + { ".debug_pubnames", ".zdebug_pubnames" }, + { ".debug_pubtypes", ".zdebug_pubtypes" }, + { ".debug_ranges", ".zdebug_ranges" }, + { ".debug_static_func", ".zdebug_static_func" }, + { ".debug_static_vars", ".zdebug_static_vars" }, + { ".debug_str", ".zdebug_str", }, + { ".debug_types", ".zdebug_types" }, + /* GNU DWARF 1 extensions */ + { ".debug_sfnames", ".zdebug_sfnames" }, + { ".debug_srcinfo", ".zebug_srcinfo" }, + /* SGI/MIPS DWARF 2 extensions */ + { ".debug_funcnames", ".zdebug_funcnames" }, + { ".debug_typenames", ".zdebug_typenames" }, + { ".debug_varnames", ".zdebug_varnames" }, + { ".debug_weaknames", ".zdebug_weaknames" }, + { NULL, NULL }, +}; + +enum dwarf_debug_section_enum +{ + debug_abbrev = 0, + debug_aranges, + debug_frame, + debug_info, + debug_line, + debug_loc, + debug_macinfo, + debug_macro, + debug_pubnames, + debug_pubtypes, + debug_ranges, + debug_static_func, + debug_static_vars, + debug_str, + debug_types, + debug_sfnames, + debug_srcinfo, + debug_funcnames, + debug_typenames, + debug_varnames, + debug_weaknames +}; + #ifndef ABBREV_HASH_SIZE #define ABBREV_HASH_SIZE 121 #endif @@ -412,24 +469,23 @@ lookup_info_hash_table (struct info_hash_table *hash_table, const char *key) static bfd_boolean read_section (bfd * abfd, - const char * section_name, - const char * compressed_section_name, + enum dwarf_debug_section_enum sec, asymbol ** syms, bfd_uint64_t offset, bfd_byte ** section_buffer, bfd_size_type * section_size) { asection *msec; - bfd_boolean section_is_compressed = FALSE; + const char *section_name = dwarf_debug_sections[sec].uncompressed_name; /* read_section is a noop if the section has already been read. */ if (!*section_buffer) { msec = bfd_get_section_by_name (abfd, section_name); - if (! msec && compressed_section_name) + if (! msec) { - msec = bfd_get_section_by_name (abfd, compressed_section_name); - section_is_compressed = TRUE; + section_name = dwarf_debug_sections[sec].compressed_name; + msec = bfd_get_section_by_name (abfd, section_name); } if (! msec) { @@ -455,16 +511,6 @@ read_section (bfd * abfd, 0, *section_size)) return FALSE; } - - if (section_is_compressed) - { - if (! bfd_uncompress_section_contents (section_buffer, section_size)) - { - (*_bfd_error_handler) (_("Dwarf Error: unable to decompress %s section."), compressed_section_name); - bfd_set_error (bfd_error_bad_value); - return FALSE; - } - } } /* It is possible to get a bad value for the offset into the section @@ -560,8 +606,7 @@ read_indirect_string (struct comp_unit * unit, *bytes_read_ptr = unit->offset_size; - if (! read_section (unit->abfd, ".debug_str", ".zdebug_str", - stash->syms, offset, + if (! read_section (unit->abfd, debug_str, stash->syms, offset, &stash->dwarf_str_buffer, &stash->dwarf_str_size)) return NULL; @@ -643,8 +688,7 @@ read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash) unsigned int abbrev_form, hash_number; bfd_size_type amt; - if (! read_section (abfd, ".debug_abbrev", ".zdebug_abbrev", - stash->syms, offset, + if (! read_section (abfd, debug_abbrev, stash->syms, offset, &stash->dwarf_abbrev_buffer, &stash->dwarf_abbrev_size)) return NULL; @@ -760,7 +804,7 @@ read_attribute_value (struct attribute *attr, case DW_FORM_ref_addr: /* DW_FORM_ref_addr is an address in DWARF2, and an offset in DWARF3. */ - if (unit->version == 3) + if (unit->version == 3 || unit->version == 4) { if (unit->offset_size == 4) attr->u.val = read_4_bytes (unit->abfd, info_ptr); @@ -774,6 +818,13 @@ read_attribute_value (struct attribute *attr, attr->u.val = read_address (unit, info_ptr); info_ptr += unit->addr_size; break; + case DW_FORM_sec_offset: + if (unit->offset_size == 4) + attr->u.val = read_4_bytes (unit->abfd, info_ptr); + else + attr->u.val = read_8_bytes (unit->abfd, info_ptr); + info_ptr += unit->offset_size; + break; case DW_FORM_block2: amt = sizeof (struct dwarf_block); blk = (struct dwarf_block *) bfd_alloc (abfd, amt); @@ -816,6 +867,7 @@ read_attribute_value (struct attribute *attr, attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read); info_ptr += bytes_read; break; + case DW_FORM_exprloc: case DW_FORM_block: amt = sizeof (struct dwarf_block); blk = (struct dwarf_block *) bfd_alloc (abfd, amt); @@ -846,6 +898,9 @@ read_attribute_value (struct attribute *attr, attr->u.val = read_1_byte (abfd, info_ptr); info_ptr += 1; break; + case DW_FORM_flag_present: + attr->u.val = 1; + break; case DW_FORM_sdata: attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read); info_ptr += bytes_read; @@ -887,6 +942,7 @@ read_attribute_value (struct attribute *attr, (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."), form); bfd_set_error (bfd_error_bad_value); + return NULL; } return info_ptr; } @@ -916,7 +972,8 @@ struct line_info char *filename; unsigned int line; unsigned int column; - int end_sequence; /* End of (sequential) code sequence. */ + unsigned char op_index; + unsigned char end_sequence; /* End of (sequential) code sequence. */ }; struct fileinfo @@ -990,7 +1047,9 @@ new_line_sorts_after (struct line_info *new_line, struct line_info *line) { return (new_line->address > line->address || (new_line->address == line->address - && new_line->end_sequence < line->end_sequence)); + && (new_line->op_index > line->op_index + || (new_line->op_index == line->op_index + && new_line->end_sequence < line->end_sequence)))); } @@ -1002,6 +1061,7 @@ new_line_sorts_after (struct line_info *new_line, struct line_info *line) static bfd_boolean add_line_info (struct line_info_table *table, bfd_vma address, + unsigned char op_index, char *filename, unsigned int line, unsigned int column, @@ -1015,7 +1075,9 @@ add_line_info (struct line_info_table *table, return FALSE; /* Set member data of 'info'. */ + info->prev_line = NULL; info->address = address; + info->op_index = op_index; info->line = line; info->column = column; info->end_sequence = end_sequence; @@ -1047,6 +1109,7 @@ add_line_info (struct line_info_table *table, if (seq && seq->last_line->address == address + && seq->last_line->op_index == op_index && seq->last_line->end_sequence == end_sequence) { /* We only keep the last entry with the same address and end @@ -1242,6 +1305,11 @@ compare_sequences (const void* a, const void* b) if (seq1->last_line->address > seq2->last_line->address) return -1; + if (seq1->last_line->op_index < seq2->last_line->op_index) + return 1; + if (seq1->last_line->op_index > seq2->last_line->op_index) + return -1; + return 0; } @@ -1328,8 +1396,7 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash) unsigned char op_code, extended_op, adj_opcode; bfd_size_type amt; - if (! read_section (abfd, ".debug_line", ".zdebug_line", - stash->syms, unit->line_offset, + if (! read_section (abfd, debug_line, stash->syms, unit->line_offset, &stash->dwarf_line_buffer, &stash->dwarf_line_size)) return NULL; @@ -1372,6 +1439,13 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash) } line_end = line_ptr + lh.total_length; lh.version = read_2_bytes (abfd, line_ptr); + if (lh.version < 2 || lh.version > 4) + { + (*_bfd_error_handler) + (_("Dwarf Error: Unhandled .debug_line version %d."), lh.version); + bfd_set_error (bfd_error_bad_value); + return NULL; + } line_ptr += 2; if (offset_size == 4) lh.prologue_length = read_4_bytes (abfd, line_ptr); @@ -1380,6 +1454,20 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash) line_ptr += offset_size; lh.minimum_instruction_length = read_1_byte (abfd, line_ptr); line_ptr += 1; + if (lh.version >= 4) + { + lh.maximum_ops_per_insn = read_1_byte (abfd, line_ptr); + line_ptr += 1; + } + else + lh.maximum_ops_per_insn = 1; + if (lh.maximum_ops_per_insn == 0) + { + (*_bfd_error_handler) + (_("Dwarf Error: Invalid maximum operations per instruction.")); + bfd_set_error (bfd_error_bad_value); + return NULL; + } lh.default_is_stmt = read_1_byte (abfd, line_ptr); line_ptr += 1; lh.line_base = read_1_signed_byte (abfd, line_ptr); @@ -1460,6 +1548,7 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash) { /* State machine registers. */ bfd_vma address = 0; + unsigned char op_index = 0; char * filename = table->num_files ? concat_filename (table, 1) : NULL; unsigned int line = 1; unsigned int column = 0; @@ -1483,11 +1572,21 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash) { /* Special operand. */ adj_opcode = op_code - lh.opcode_base; - address += (adj_opcode / lh.line_range) - * lh.minimum_instruction_length; + if (lh.maximum_ops_per_insn == 1) + address += (adj_opcode / lh.line_range) + * lh.minimum_instruction_length; + else + { + address += ((op_index + (adj_opcode / lh.line_range)) + / lh.maximum_ops_per_insn) + * lh.minimum_instruction_length; + op_index = (op_index + (adj_opcode / lh.line_range)) + % lh.maximum_ops_per_insn; + } line += lh.line_base + (adj_opcode % lh.line_range); /* Append row to matrix using current values. */ - if (!add_line_info (table, address, filename, line, column, 0)) + if (!add_line_info (table, address, op_index, filename, + line, column, 0)) goto line_fail; if (address < low_pc) low_pc = address; @@ -1506,8 +1605,8 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash) { case DW_LNE_end_sequence: end_sequence = 1; - if (!add_line_info (table, address, filename, line, column, - end_sequence)) + if (!add_line_info (table, address, op_index, filename, + line, column, end_sequence)) goto line_fail; if (address < low_pc) low_pc = address; @@ -1518,6 +1617,7 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash) break; case DW_LNE_set_address: address = read_address (unit, line_ptr); + op_index = 0; line_ptr += unit->addr_size; break; case DW_LNE_define_file: @@ -1560,7 +1660,8 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash) } break; case DW_LNS_copy: - if (!add_line_info (table, address, filename, line, column, 0)) + if (!add_line_info (table, address, op_index, + filename, line, column, 0)) goto line_fail; if (address < low_pc) low_pc = address; @@ -1568,8 +1669,18 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash) high_pc = address; break; case DW_LNS_advance_pc: - address += lh.minimum_instruction_length - * read_unsigned_leb128 (abfd, line_ptr, &bytes_read); + if (lh.maximum_ops_per_insn == 1) + address += lh.minimum_instruction_length + * read_unsigned_leb128 (abfd, line_ptr, + &bytes_read); + else + { + bfd_vma adjust = read_unsigned_leb128 (abfd, line_ptr, + &bytes_read); + address = ((op_index + adjust) / lh.maximum_ops_per_insn) + * lh.minimum_instruction_length; + op_index = (op_index + adjust) % lh.maximum_ops_per_insn; + } line_ptr += bytes_read; break; case DW_LNS_advance_line: @@ -1599,11 +1710,20 @@ decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash) case DW_LNS_set_basic_block: break; case DW_LNS_const_add_pc: - address += lh.minimum_instruction_length - * ((255 - lh.opcode_base) / lh.line_range); + if (lh.maximum_ops_per_insn == 1) + address += lh.minimum_instruction_length + * ((255 - lh.opcode_base) / lh.line_range); + else + { + bfd_vma adjust = ((255 - lh.opcode_base) / lh.line_range); + address += lh.minimum_instruction_length + * ((op_index + adjust) / lh.maximum_ops_per_insn); + op_index = (op_index + adjust) % lh.maximum_ops_per_insn; + } break; case DW_LNS_fixed_advance_pc: address += read_2_bytes (abfd, line_ptr); + op_index = 0; line_ptr += 2; break; default: @@ -1691,8 +1811,7 @@ static bfd_boolean read_debug_ranges (struct comp_unit *unit) { struct dwarf2_debug *stash = unit->stash; - return read_section (unit->abfd, ".debug_ranges", ".zdebug_ranges", - stash->syms, 0, + return read_section (unit->abfd, debug_ranges, stash->syms, 0, &stash->dwarf_ranges_buffer, &stash->dwarf_ranges_size); } @@ -1873,13 +1992,15 @@ find_abstract_instance_name (struct comp_unit *unit, switch (attr.name) { case DW_AT_name: - /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */ + /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name + over DW_AT_name. */ if (name == NULL) name = attr.u.str; break; case DW_AT_specification: name = find_abstract_instance_name (unit, &attr); break; + case DW_AT_linkage_name: case DW_AT_MIPS_linkage_name: name = attr.u.str; break; @@ -2029,7 +2150,7 @@ scan_unit_for_symbols (struct comp_unit *unit) { info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr); if (info_ptr == NULL) - return FALSE; + goto fail; if (func) { @@ -2045,15 +2166,18 @@ scan_unit_for_symbols (struct comp_unit *unit) break; case DW_AT_abstract_origin: + case DW_AT_specification: func->name = find_abstract_instance_name (unit, &attr); break; case DW_AT_name: - /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */ + /* Prefer DW_AT_MIPS_linkage_name or DW_AT_linkage_name + over DW_AT_name. */ if (func->name == NULL) func->name = attr.u.str; break; + case DW_AT_linkage_name: case DW_AT_MIPS_linkage_name: func->name = attr.u.str; break; @@ -2113,6 +2237,7 @@ scan_unit_for_symbols (struct comp_unit *unit) case DW_FORM_block1: case DW_FORM_block2: case DW_FORM_block4: + case DW_FORM_exprloc: if (*attr.u.blk->data == DW_OP_addr) { var->stack = 0; @@ -2216,9 +2341,9 @@ parse_comp_unit (struct dwarf2_debug *stash, addr_size = read_1_byte (abfd, info_ptr); info_ptr += 1; - if (version != 2 && version != 3) + if (version != 2 && version != 3 && version != 4) { - (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 and 3 information."), version); + (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2, 3 and 4 information."), version); bfd_set_error (bfd_error_bad_value); return 0; } @@ -3109,86 +3234,37 @@ find_line (bfd *abfd, { /* Case 1: only one info section. */ total_size = msec->size; - if (! read_section (debug_bfd, ".debug_info", ".zdebug_info", - symbols, 0, + if (! read_section (debug_bfd, debug_info, symbols, 0, &stash->info_ptr_memory, &total_size)) goto done; } else { - int all_uncompressed = 1; + /* Case 2: multiple sections. */ for (total_size = 0; msec; msec = find_debug_info (debug_bfd, msec)) - { - total_size += msec->size; - if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0) - all_uncompressed = 0; - } - if (all_uncompressed) - { - /* Case 2: multiple sections, but none is compressed. */ - stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size); - if (stash->info_ptr_memory == NULL) - goto done; - - total_size = 0; - for (msec = find_debug_info (debug_bfd, NULL); - msec; - msec = find_debug_info (debug_bfd, msec)) - { - bfd_size_type size; + total_size += msec->size; - size = msec->size; - if (size == 0) - continue; - - if (!(bfd_simple_get_relocated_section_contents - (debug_bfd, msec, stash->info_ptr_memory + total_size, - symbols))) - goto done; + stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size); + if (stash->info_ptr_memory == NULL) + goto done; - total_size += size; - } - } - else + total_size = 0; + for (msec = find_debug_info (debug_bfd, NULL); + msec; + msec = find_debug_info (debug_bfd, msec)) { - /* Case 3: multiple sections, some or all compressed. */ - stash->info_ptr_memory = NULL; - total_size = 0; - for (msec = find_debug_info (debug_bfd, NULL); - msec; - msec = find_debug_info (debug_bfd, msec)) - { - bfd_size_type size = msec->size; - bfd_byte *buffer, *tmp; + bfd_size_type size; - if (size == 0) - continue; + size = msec->size; + if (size == 0) + continue; - buffer = (bfd_simple_get_relocated_section_contents - (debug_bfd, msec, NULL, symbols)); - if (! buffer) - goto done; + if (!(bfd_simple_get_relocated_section_contents + (debug_bfd, msec, stash->info_ptr_memory + total_size, + symbols))) + goto done; - if (strcmp (msec->name, DWARF2_COMPRESSED_DEBUG_INFO) == 0) - { - if (! bfd_uncompress_section_contents (&buffer, &size)) - { - free (buffer); - goto done; - } - } - tmp = (bfd_byte *) bfd_realloc (stash->info_ptr_memory, - total_size + size); - if (tmp == NULL) - { - free (buffer); - goto done; - } - stash->info_ptr_memory = tmp; - memcpy (stash->info_ptr_memory + total_size, buffer, size); - free (buffer); - total_size += size; - } + total_size += size; } }