X-Git-Url: http://drtracing.org/?a=blobdiff_plain;ds=sidebyside;f=gdb%2Fdwarf2read.c;h=5860c572d54cf30e6f21929384373fc6781a0077;hb=439247b656ce3bcfaa00fec7dbce70e65ca17cf5;hp=837b1c1a9fc629c417918a44961dfaaa96be2904;hpb=8e07a239c12ba3b746ef0cf2c53d572315aef654;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index 837b1c1a9f..5860c572d5 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -55,7 +55,6 @@ #include "typeprint.h" #include "jv-lang.h" #include "psympriv.h" -#include "exceptions.h" #include #include "completer.h" #include "vec.h" @@ -72,8 +71,6 @@ #include "build-id.h" #include -#include -#include "gdb_assert.h" #include typedef struct symbol *symbolp; @@ -613,8 +610,8 @@ struct dwarf2_per_cu_data However we can enter this file with just a "per_cu" handle. */ struct objfile *objfile; - /* When using partial symbol tables, the 'psymtab' field is active. - Otherwise the 'quick' field is active. */ + /* When dwarf2_per_objfile->using_index is true, the 'quick' field + is active. Otherwise, the 'psymtab' field is active. */ union { /* The partial symbol table associated with this compilation unit, @@ -1389,10 +1386,10 @@ static void add_partial_symbol (struct partial_die_info *, static void add_partial_namespace (struct partial_die_info *pdi, CORE_ADDR *lowpc, CORE_ADDR *highpc, - int need_pc, struct dwarf2_cu *cu); + int set_addrmap, struct dwarf2_cu *cu); static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc, - CORE_ADDR *highpc, int need_pc, + CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu); static void add_partial_enumeration (struct partial_die_info *enum_pdi, @@ -1515,9 +1512,9 @@ static struct line_header *dwarf_decode_line_header (unsigned int offset, static void dwarf_decode_lines (struct line_header *, const char *, struct dwarf2_cu *, struct partial_symtab *, - int); + CORE_ADDR); -static void dwarf2_start_subfile (const char *, const char *, const char *); +static void dwarf2_start_subfile (const char *, const char *); static void dwarf2_start_symtab (struct dwarf2_cu *, const char *, const char *, CORE_ADDR); @@ -2663,6 +2660,10 @@ dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu) process_cu_includes (); do_cleanups (back_to); } + + /* The result of symtab expansion is always the primary symtab. */ + gdb_assert (per_cu->v.quick->symtab->primary); + return per_cu->v.quick->symtab; } @@ -2920,7 +2921,11 @@ find_slot_in_mapped_hash (struct mapped_index *index, const char *name, { /* NAME is already canonical. Drop any qualifiers as .gdb_index does not contain any. */ - const char *paren = strchr (name, '('); + const char *paren = NULL; + + /* Need to handle "(anonymous namespace)". */ + if (*name != '(') + paren = strchr (name, '('); if (paren) { @@ -3610,17 +3615,13 @@ dw2_lookup_symbol (struct objfile *objfile, int block_index, { struct symbol *sym = NULL; struct symtab *stab = dw2_instantiate_symtab (per_cu); + const struct blockvector *bv = SYMTAB_BLOCKVECTOR (stab); + struct block *block = BLOCKVECTOR_BLOCK (bv, block_index); /* Some caution must be observed with overloaded functions and methods, since the index will not contain any overload information (but NAME might contain it). */ - if (stab->primary) - { - const struct blockvector *bv = BLOCKVECTOR (stab); - struct block *block = BLOCKVECTOR_BLOCK (bv, block_index); - - sym = lookup_block_symbol (block, name, domain); - } + sym = block_lookup_symbol (block, name, domain); if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0) { @@ -3969,8 +3970,8 @@ recursively_find_pc_sect_symtab (struct symtab *symtab, CORE_ADDR pc) { int i; - if (BLOCKVECTOR (symtab) != NULL - && blockvector_contains_pc (BLOCKVECTOR (symtab), pc)) + if (SYMTAB_BLOCKVECTOR (symtab) != NULL + && blockvector_contains_pc (SYMTAB_BLOCKVECTOR (symtab), pc)) return symtab; if (symtab->includes == NULL) @@ -4451,7 +4452,7 @@ dwarf2_build_include_psymtabs (struct dwarf2_cu *cu, return; /* No linetable, so no includes. */ /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */ - dwarf_decode_lines (lh, pst->dirname, cu, pst, 1); + dwarf_decode_lines (lh, pst->dirname, cu, pst, pst->textlow); free_line_header (lh); } @@ -6544,15 +6545,15 @@ create_all_comp_units (struct objfile *objfile) } /* Process all loaded DIEs for compilation unit CU, starting at - FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation + FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or - DW_AT_ranges). If NEED_PC is set, then this function will set - *LOWPC and *HIGHPC to the lowest and highest PC values found in CU - and record the covered ranges in the addrmap. */ + DW_AT_ranges). See the comments of add_partial_subprogram on how + SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */ static void scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc, - CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu) + CORE_ADDR *highpc, int set_addrmap, + struct dwarf2_cu *cu) { struct partial_die_info *pdi; @@ -6577,7 +6578,7 @@ scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc, switch (pdi->tag) { case DW_TAG_subprogram: - add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu); + add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu); break; case DW_TAG_constant: case DW_TAG_variable: @@ -6607,10 +6608,10 @@ scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc, add_partial_symbol (pdi, cu); break; case DW_TAG_namespace: - add_partial_namespace (pdi, lowpc, highpc, need_pc, cu); + add_partial_namespace (pdi, lowpc, highpc, set_addrmap, cu); break; case DW_TAG_module: - add_partial_module (pdi, lowpc, highpc, need_pc, cu); + add_partial_module (pdi, lowpc, highpc, set_addrmap, cu); break; case DW_TAG_imported_unit: { @@ -6977,7 +6978,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) static void add_partial_namespace (struct partial_die_info *pdi, CORE_ADDR *lowpc, CORE_ADDR *highpc, - int need_pc, struct dwarf2_cu *cu) + int set_addrmap, struct dwarf2_cu *cu) { /* Add a symbol for the namespace. */ @@ -6986,14 +6987,14 @@ add_partial_namespace (struct partial_die_info *pdi, /* Now scan partial symbols in that namespace. */ if (pdi->has_children) - scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu); + scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu); } /* Read a partial die corresponding to a Fortran module. */ static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc, - CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu) + CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu) { /* Add a symbol for the namespace. */ @@ -7002,23 +7003,25 @@ add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc, /* Now scan partial symbols in that module. */ if (pdi->has_children) - scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu); + scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu); } /* Read a partial die corresponding to a subprogram and create a partial symbol for that subprogram. When the CU language allows it, this routine also defines a partial symbol for each nested subprogram - that this subprogram contains. + that this subprogram contains. If SET_ADDRMAP is true, record the + covered ranges in the addrmap. Set *LOWPC and *HIGHPC to the lowest + and highest PC values found in PDI. - DIE my also be a lexical block, in which case we simply search - recursively for suprograms defined inside that lexical block. + PDI may also be a lexical block, in which case we simply search + recursively for subprograms defined inside that lexical block. Again, this is only performed when the CU language allows this type of definitions. */ static void add_partial_subprogram (struct partial_die_info *pdi, CORE_ADDR *lowpc, CORE_ADDR *highpc, - int need_pc, struct dwarf2_cu *cu) + int set_addrmap, struct dwarf2_cu *cu) { if (pdi->tag == DW_TAG_subprogram) { @@ -7028,7 +7031,7 @@ add_partial_subprogram (struct partial_die_info *pdi, *lowpc = pdi->lowpc; if (pdi->highpc > *highpc) *highpc = pdi->highpc; - if (need_pc) + if (set_addrmap) { CORE_ADDR baseaddr; struct objfile *objfile = cu->objfile; @@ -7064,7 +7067,7 @@ add_partial_subprogram (struct partial_die_info *pdi, fixup_partial_die (pdi, cu); if (pdi->tag == DW_TAG_subprogram || pdi->tag == DW_TAG_lexical_block) - add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu); + add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu); pdi = pdi->die_sibling; } } @@ -7957,7 +7960,7 @@ process_full_comp_unit (struct dwarf2_per_cu_data *per_cu, get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu); static_block - = end_symtab_get_static_block (highpc + baseaddr, objfile, 0, 1); + = end_symtab_get_static_block (highpc + baseaddr, 0, 1); /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges. Also, DW_AT_ranges may record ranges not belonging to any child DIEs @@ -7966,7 +7969,7 @@ process_full_comp_unit (struct dwarf2_per_cu_data *per_cu, this comp unit. */ dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu); - symtab = end_symtab_from_static_block (static_block, objfile, + symtab = end_symtab_from_static_block (static_block, SECT_OFF_TEXT (objfile), 0); if (symtab != NULL) @@ -8059,7 +8062,7 @@ process_full_type_unit (struct dwarf2_per_cu_data *per_cu, this TU's symbols to the existing symtab. */ if (sig_type->type_unit_group->primary_symtab == NULL) { - symtab = end_expandable_symtab (0, objfile, SECT_OFF_TEXT (objfile)); + symtab = end_expandable_symtab (0, SECT_OFF_TEXT (objfile)); sig_type->type_unit_group->primary_symtab = symtab; if (symtab != NULL) @@ -8074,8 +8077,7 @@ process_full_type_unit (struct dwarf2_per_cu_data *per_cu, } else { - augment_type_symtab (objfile, - sig_type->type_unit_group->primary_symtab); + augment_type_symtab (sig_type->type_unit_group->primary_symtab); symtab = sig_type->type_unit_group->primary_symtab; } @@ -8968,12 +8970,12 @@ find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu, /* Handle DW_AT_stmt_list for a compilation unit. DIE is the DW_TAG_compile_unit die for CU. - COMP_DIR is the compilation directory. - WANT_LINE_INFO is non-zero if the pc/line-number mapping is needed. */ + COMP_DIR is the compilation directory. LOWPC is passed to + dwarf_decode_lines. See dwarf_decode_lines comments about it. */ static void handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu, - const char *comp_dir) /* ARI: editCase function */ + const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */ { struct attribute *attr; @@ -8990,7 +8992,7 @@ handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu, { cu->line_header = line_header; make_cleanup (free_cu_line_header, cu); - dwarf_decode_lines (line_header, comp_dir, cu, NULL, 1); + dwarf_decode_lines (line_header, comp_dir, cu, NULL, lowpc); } } } @@ -9041,7 +9043,7 @@ read_file_scope (struct die_info *die, struct dwarf2_cu *cu) /* Decode line number information if present. We do this before processing child DIEs, so that the line header table is available for DW_AT_decl_file. */ - handle_DW_AT_stmt_list (die, cu, comp_dir); + handle_DW_AT_stmt_list (die, cu, comp_dir, lowpc); /* Process all dies in compilation unit. */ if (die->child != NULL) @@ -9154,7 +9156,7 @@ setup_type_unit_groups (struct die_info *die, struct dwarf2_cu *cu) if (fe->dir_index) dir = lh->include_dirs[fe->dir_index - 1]; - dwarf2_start_subfile (fe->name, dir, NULL); + dwarf2_start_subfile (fe->name, dir); /* Note: We don't have to watch for the main subfile here, type units don't have DW_AT_name. */ @@ -11260,7 +11262,7 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu) new = pop_context (); /* Make a block for the local symbols within. */ block = finish_block (new->name, &local_symbols, new->old_blocks, - lowpc, highpc, objfile); + lowpc, highpc); /* For C++, set the block's scope. */ if ((cu->language == language_cplus || cu->language == language_fortran) @@ -11340,7 +11342,7 @@ read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu) { struct block *block = finish_block (0, &local_symbols, new->old_blocks, new->start_addr, - highpc, objfile); + highpc); /* Note that recording ranges after traversing children, as we do here, means that recording a parent's ranges entails @@ -12966,7 +12968,7 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu) } else { - TYPE_CODE (type) = TYPE_CODE_CLASS; + TYPE_CODE (type) = TYPE_CODE_STRUCT; } if (cu->language == language_cplus && die->tag == DW_TAG_class_type) @@ -13017,7 +13019,7 @@ static void process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; - struct die_info *child_die = die->child; + struct die_info *child_die; struct type *type; type = get_die_type (die, cu); @@ -13027,7 +13029,6 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) if (die->child != NULL && ! die_is_declaration (die, cu)) { struct field_info fi; - struct die_info *child_die; VEC (symbolp) *template_args = NULL; struct cleanup *back_to = make_cleanup (null_cleanup, 0); @@ -13198,6 +13199,8 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) current die is a declaration. Normally, of course, a declaration won't have any children at all. */ + child_die = die->child; + while (child_die != NULL && child_die->tag) { if (child_die->tag == DW_TAG_member @@ -13231,7 +13234,7 @@ update_enumeration_type_from_children (struct die_info *die, struct dwarf2_cu *cu) { struct obstack obstack; - struct die_info *child_die = die->child; + struct die_info *child_die; int unsigned_enum = 1; int flag_enum = 1; ULONGEST mask = 0; @@ -13240,13 +13243,16 @@ update_enumeration_type_from_children (struct die_info *die, obstack_init (&obstack); old_chain = make_cleanup_obstack_free (&obstack); - while (child_die != NULL && child_die->tag) + for (child_die = die->child; + child_die != NULL && child_die->tag; + child_die = sibling_die (child_die)) { struct attribute *attr; LONGEST value; const gdb_byte *bytes; struct dwarf2_locexpr_baton *baton; const char *name; + if (child_die->tag != DW_TAG_enumerator) continue; @@ -13274,7 +13280,6 @@ update_enumeration_type_from_children (struct die_info *die, a flag type, no need to look at the rest of the enumerates. */ if (!unsigned_enum && !flag_enum) break; - child_die = sibling_die (child_die); } if (unsigned_enum) @@ -17127,7 +17132,9 @@ psymtab_include_file_name (const struct line_header *lh, int file_index, include_name = "hello.c" dir_name = "." DW_AT_comp_dir = comp_dir = "/tmp" - DW_AT_name = "./hello.c" */ + DW_AT_name = "./hello.c" + + */ if (dir_name != NULL) { @@ -17174,22 +17181,95 @@ noop_record_line (struct subfile *subfile, int line, CORE_ADDR pc) return; } +/* Return non-zero if we should add LINE to the line number table. + LINE is the line to add, LAST_LINE is the last line that was added, + LAST_SUBFILE is the subfile for LAST_LINE. + LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever + had a non-zero discriminator. + + We have to be careful in the presence of discriminators. + E.g., for this line: + + for (i = 0; i < 100000; i++); + + clang can emit four line number entries for that one line, + each with a different discriminator. + See gdb.dwarf2/dw2-single-line-discriminators.exp for an example. + + However, we want gdb to coalesce all four entries into one. + Otherwise the user could stepi into the middle of the line and + gdb would get confused about whether the pc really was in the + middle of the line. + + Things are further complicated by the fact that two consecutive + line number entries for the same line is a heuristic used by gcc + to denote the end of the prologue. So we can't just discard duplicate + entries, we have to be selective about it. The heuristic we use is + that we only collapse consecutive entries for the same line if at least + one of those entries has a non-zero discriminator. PR 17276. + + Note: Addresses in the line number state machine can never go backwards + within one sequence, thus this coalescing is ok. */ + +static int +dwarf_record_line_p (unsigned int line, unsigned int last_line, + int line_has_non_zero_discriminator, + struct subfile *last_subfile) +{ + if (current_subfile != last_subfile) + return 1; + if (line != last_line) + return 1; + /* Same line for the same file that we've seen already. + As a last check, for pr 17276, only record the line if the line + has never had a non-zero discriminator. */ + if (!line_has_non_zero_discriminator) + return 1; + return 0; +} + +/* Use P_RECORD_LINE to record line number LINE beginning at address ADDRESS + in the line table of subfile SUBFILE. */ + +static void +dwarf_record_line (struct gdbarch *gdbarch, struct subfile *subfile, + unsigned int line, CORE_ADDR address, + record_line_ftype p_record_line) +{ + CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address); + + (*p_record_line) (subfile, line, addr); +} + +/* Subroutine of dwarf_decode_lines_1 to simplify it. + Mark the end of a set of line number records. + The arguments are the same as for dwarf_record_line. + If SUBFILE is NULL the request is ignored. */ + +static void +dwarf_finish_line (struct gdbarch *gdbarch, struct subfile *subfile, + CORE_ADDR address, record_line_ftype p_record_line) +{ + if (subfile != NULL) + dwarf_record_line (gdbarch, subfile, 0, address, p_record_line); +} + /* Subroutine of dwarf_decode_lines to simplify it. Process the line number information in LH. */ static void dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, - struct dwarf2_cu *cu, struct partial_symtab *pst) + struct dwarf2_cu *cu, const int decode_for_pst_p, + CORE_ADDR lowpc) { const gdb_byte *line_ptr, *extended_end; const gdb_byte *line_end; unsigned int bytes_read, extended_len; - unsigned char op_code, extended_op, adj_opcode; + unsigned char op_code, extended_op; CORE_ADDR baseaddr; struct objfile *objfile = cu->objfile; bfd *abfd = objfile->obfd; struct gdbarch *gdbarch = get_objfile_arch (objfile); - const int decode_for_pst_p = (pst != NULL); struct subfile *last_subfile = NULL; void (*p_record_line) (struct subfile *subfile, int line, CORE_ADDR pc) = record_line; @@ -17206,12 +17286,15 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, CORE_ADDR address = 0; unsigned int file = 1; unsigned int line = 1; - unsigned int column = 0; int is_stmt = lh->default_is_stmt; - int basic_block = 0; int end_sequence = 0; - CORE_ADDR addr; unsigned char op_index = 0; + unsigned int discriminator = 0; + /* The last line number that was recorded, used to coalesce + consecutive entries for the same line. This can happen, for + example, when discriminators are present. PR 17276. */ + unsigned int last_line = 0; + int line_has_non_zero_discriminator = 0; if (!decode_for_pst_p && lh->num_file_names >= file) { @@ -17225,7 +17308,7 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, if (fe->dir_index) dir = lh->include_dirs[fe->dir_index - 1]; - dwarf2_start_subfile (fe->name, dir, comp_dir); + dwarf2_start_subfile (fe->name, dir); } /* Decode the table. */ @@ -17242,6 +17325,8 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, if (op_code >= lh->opcode_base) { /* Special opcode. */ + unsigned char adj_opcode; + int line_delta; adj_opcode = op_code - lh->opcode_base; address += (((op_index + (adj_opcode / lh->line_range)) @@ -17249,7 +17334,10 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, * lh->minimum_instruction_length); op_index = ((op_index + (adj_opcode / lh->line_range)) % lh->maximum_ops_per_instruction); - line += lh->line_base + (adj_opcode % lh->line_range); + line_delta = lh->line_base + (adj_opcode % lh->line_range); + line += line_delta; + if (line_delta != 0) + line_has_non_zero_discriminator = discriminator != 0; if (lh->num_file_names < file || file == 0) dwarf2_debug_line_missing_file_complaint (); /* For now we ignore lines not starting on an @@ -17261,17 +17349,21 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, { if (last_subfile != current_subfile) { - addr = gdbarch_addr_bits_remove (gdbarch, address); - if (last_subfile) - (*p_record_line) (last_subfile, 0, addr); - last_subfile = current_subfile; + dwarf_finish_line (gdbarch, last_subfile, + address, p_record_line); } - /* Append row to matrix using current values. */ - addr = gdbarch_addr_bits_remove (gdbarch, address); - (*p_record_line) (current_subfile, line, addr); + if (dwarf_record_line_p (line, last_line, + line_has_non_zero_discriminator, + last_subfile)) + { + dwarf_record_line (gdbarch, current_subfile, + line, address, p_record_line); + } + last_subfile = current_subfile; + last_line = line; } } - basic_block = 0; + discriminator = 0; } else switch (op_code) { @@ -17291,7 +17383,12 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, case DW_LNE_set_address: address = read_address (abfd, line_ptr, cu, &bytes_read); - if (address == 0 && !dwarf2_per_objfile->has_section_at_zero) + /* If address < lowpc then it's not a usable value, it's + outside the pc range of the CU. However, we restrict + the test to only address values of zero to preserve + GDB's previous behaviour which is to handle the specific + case of a function being GC'd by the linker. */ + if (address == 0 && address < lowpc) { /* This line table is for a function which has been GCd by the linker. Ignore it. PR gdb/12528 */ @@ -17304,6 +17401,8 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, "[in module %s]"), line_offset, objfile_name (objfile)); p_record_line = noop_record_line; + /* Note: p_record_line is left as noop_record_line + until we see DW_LNE_end_sequence. */ } op_index = 0; @@ -17332,8 +17431,14 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, break; case DW_LNE_set_discriminator: /* The discriminator is not interesting to the debugger; - just ignore it. */ - line_ptr = extended_end; + just ignore it. We still need to check its value though: + if there are consecutive entries for the same + (non-prologue) line we want to coalesce them. + PR 17276. */ + discriminator = read_unsigned_leb128 (abfd, line_ptr, + &bytes_read); + line_has_non_zero_discriminator |= discriminator != 0; + line_ptr += bytes_read; break; default: complaint (&symfile_complaints, @@ -17360,16 +17465,21 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, { if (last_subfile != current_subfile) { - addr = gdbarch_addr_bits_remove (gdbarch, address); - if (last_subfile) - (*p_record_line) (last_subfile, 0, addr); - last_subfile = current_subfile; + dwarf_finish_line (gdbarch, last_subfile, + address, p_record_line); + } + if (dwarf_record_line_p (line, last_line, + line_has_non_zero_discriminator, + last_subfile)) + { + dwarf_record_line (gdbarch, current_subfile, + line, address, p_record_line); } - addr = gdbarch_addr_bits_remove (gdbarch, address); - (*p_record_line) (current_subfile, line, addr); + last_subfile = current_subfile; + last_line = line; } } - basic_block = 0; + discriminator = 0; break; case DW_LNS_advance_pc: { @@ -17385,8 +17495,15 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, } break; case DW_LNS_advance_line: - line += read_signed_leb128 (abfd, line_ptr, &bytes_read); - line_ptr += bytes_read; + { + int line_delta + = read_signed_leb128 (abfd, line_ptr, &bytes_read); + + line += line_delta; + if (line_delta != 0) + line_has_non_zero_discriminator = discriminator != 0; + line_ptr += bytes_read; + } break; case DW_LNS_set_file: { @@ -17408,20 +17525,20 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, if (!decode_for_pst_p) { last_subfile = current_subfile; - dwarf2_start_subfile (fe->name, dir, comp_dir); + line_has_non_zero_discriminator = discriminator != 0; + dwarf2_start_subfile (fe->name, dir); } } } break; case DW_LNS_set_column: - column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); + (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read); line_ptr += bytes_read; break; case DW_LNS_negate_stmt: is_stmt = (!is_stmt); break; case DW_LNS_set_basic_block: - basic_block = 1; break; /* Add to the address register of the state machine the address increment value corresponding to special opcode @@ -17464,8 +17581,8 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, lh->file_names[file - 1].included_p = 1; if (!decode_for_pst_p) { - addr = gdbarch_addr_bits_remove (gdbarch, address); - (*p_record_line) (current_subfile, 0, addr); + dwarf_finish_line (gdbarch, current_subfile, address, + p_record_line); } } } @@ -17491,19 +17608,20 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, as the corresponding symtab. Since COMP_DIR is not used in the name of the symtab we don't use it in the name of the psymtabs we create. E.g. expand_line_sal requires this when finding psymtabs to expand. - A good testcase for this is mb-inline.exp. */ + A good testcase for this is mb-inline.exp. + + LOWPC is the lowest address in CU (or 0 if not known). */ static void dwarf_decode_lines (struct line_header *lh, const char *comp_dir, struct dwarf2_cu *cu, struct partial_symtab *pst, - int want_line_info) + CORE_ADDR lowpc) { struct objfile *objfile = cu->objfile; const int decode_for_pst_p = (pst != NULL); struct subfile *first_subfile = current_subfile; - if (want_line_info) - dwarf_decode_lines_1 (lh, comp_dir, cu, pst); + dwarf_decode_lines_1 (lh, comp_dir, cu, decode_for_pst_p, lowpc); if (decode_for_pst_p) { @@ -17535,7 +17653,7 @@ dwarf_decode_lines (struct line_header *lh, const char *comp_dir, fe = &lh->file_names[i]; if (fe->dir_index) dir = lh->include_dirs[fe->dir_index - 1]; - dwarf2_start_subfile (fe->name, dir, comp_dir); + dwarf2_start_subfile (fe->name, dir); /* Skip the main file; we don't need it, and it must be allocated last, so that it will show up before the @@ -17553,8 +17671,7 @@ dwarf_decode_lines (struct line_header *lh, const char *comp_dir, /* Start a subfile for DWARF. FILENAME is the name of the file and DIRNAME the name of the source directory which contains FILENAME - or NULL if not known. COMP_DIR is the compilation directory for the - linetable's compilation unit or NULL if not known. + or NULL if not known. This routine tries to keep line numbers from identical absolute and relative file names in a common subfile. @@ -17563,7 +17680,7 @@ dwarf_decode_lines (struct line_header *lh, const char *comp_dir, of /srcdir/list0.c yields the following debugging information for list0.c: DW_AT_name: /srcdir/list0.c - DW_AT_comp_dir: /compdir + DW_AT_comp_dir: /compdir files.files[0].name: list0.h files.files[0].dir: /srcdir files.files[1].name: list0.c @@ -17576,15 +17693,11 @@ dwarf_decode_lines (struct line_header *lh, const char *comp_dir, subfile's name. */ static void -dwarf2_start_subfile (const char *filename, const char *dirname, - const char *comp_dir) +dwarf2_start_subfile (const char *filename, const char *dirname) { char *copy = NULL; - /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir). - `start_symtab' will always pass the contents of DW_AT_comp_dir as - second argument to start_subfile. To be consistent, we do the - same here. In order not to lose the line information directory, + /* In order not to lose the line information directory, we concatenate it to the filename when it makes sense. Note that the Dwarf3 standard says (speaking of filenames in line information): ``The directory index is ignored for file names @@ -17597,7 +17710,7 @@ dwarf2_start_subfile (const char *filename, const char *dirname, filename = copy; } - start_subfile (filename, comp_dir); + start_subfile (filename); if (copy != NULL) xfree (copy); @@ -17610,7 +17723,7 @@ static void dwarf2_start_symtab (struct dwarf2_cu *cu, const char *name, const char *comp_dir, CORE_ADDR low_pc) { - start_symtab (name, comp_dir, low_pc); + start_symtab (dwarf2_per_objfile->objfile, name, comp_dir, low_pc); record_debugformat ("DWARF 2"); record_producer (cu->producer); @@ -18921,7 +19034,7 @@ dwarf2_name (struct die_info *die, struct dwarf2_cu *cu) /* GCJ will output '' for Java constructor names. For this special case, return the name of the parent class. */ - /* GCJ may output suprogram DIEs with AT_specification set. + /* GCJ may output subprogram DIEs with AT_specification set. If so, use the name of the specified DIE. */ spec_die = die_specification (die, &spec_cu); if (spec_die != NULL) @@ -20253,7 +20366,7 @@ static struct macro_source_file * macro_start_file (int file, int line, struct macro_source_file *current_file, const char *comp_dir, - struct line_header *lh, struct objfile *objfile) + struct line_header *lh) { /* File name relative to the compilation directory of this source file. */ char *file_name = file_file_name (file, lh); @@ -20262,7 +20375,7 @@ macro_start_file (int file, int line, { /* Note: We don't create a macro table for this compilation unit at all until we actually get a filename. */ - struct macro_table *macro_table = get_macro_table (objfile, comp_dir); + struct macro_table *macro_table = get_macro_table (comp_dir); /* If we have no current file, then this must be the start_file directive for the compilation unit's main source file. */ @@ -20644,9 +20757,9 @@ dwarf_decode_macro_bytes (bfd *abfd, struct dwarf2_section_info *section, int section_is_gnu, int section_is_dwz, unsigned int offset_size, - struct objfile *objfile, htab_t include_hash) { + struct objfile *objfile = dwarf2_per_objfile->objfile; enum dwarf_macro_record_type macinfo_type; int at_commandline; const gdb_byte *opcode_definitions[256]; @@ -20787,9 +20900,8 @@ dwarf_decode_macro_bytes (bfd *abfd, at_commandline = 0; } else - current_file = macro_start_file (file, line, - current_file, comp_dir, - lh, objfile); + current_file = macro_start_file (file, line, current_file, + comp_dir, lh); } break; @@ -20849,8 +20961,7 @@ dwarf_decode_macro_bytes (bfd *abfd, { struct dwz_file *dwz = dwarf2_get_dwz_file (); - dwarf2_read_section (dwarf2_per_objfile->objfile, - &dwz->macro); + dwarf2_read_section (objfile, &dwz->macro); include_section = &dwz->macro; include_bfd = get_section_bfd_owner (include_section); @@ -20877,7 +20988,7 @@ dwarf_decode_macro_bytes (bfd *abfd, include_mac_end, current_file, lh, comp_dir, section, section_is_gnu, is_dwz, - offset_size, objfile, include_hash); + offset_size, include_hash); htab_remove_elt (include_hash, (void *) new_mac_ptr); } @@ -21033,7 +21144,7 @@ dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset, mac_ptr += bytes_read; current_file = macro_start_file (file, line, current_file, - comp_dir, lh, objfile); + comp_dir, lh); } break; @@ -21099,8 +21210,7 @@ dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset, *slot = (void *) mac_ptr; dwarf_decode_macro_bytes (abfd, mac_ptr, mac_end, current_file, lh, comp_dir, section, - section_is_gnu, 0, - offset_size, objfile, include_hash); + section_is_gnu, 0, offset_size, include_hash); do_cleanups (cleanup); } @@ -21674,6 +21784,8 @@ set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu) { struct dwarf2_per_cu_offset_and_type **slot, ofs; struct objfile *objfile = cu->objfile; + struct attribute *attr; + struct dynamic_prop prop; /* For Ada types, make sure that the gnat-specific data is always initialized (if not already set). There are a few types where @@ -21688,6 +21800,15 @@ set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu) && !HAVE_GNAT_AUX_INFO (type)) INIT_GNAT_SPECIFIC (type); + /* Read DW_AT_data_location and set in type. */ + attr = dwarf2_attr (die, DW_AT_data_location, cu); + if (attr_to_dynamic_prop (attr, die, cu, &prop)) + { + TYPE_DATA_LOCATION (type) + = obstack_alloc (&objfile->objfile_obstack, sizeof (prop)); + *TYPE_DATA_LOCATION (type) = prop; + } + if (dwarf2_per_objfile->die_type_hash == NULL) { dwarf2_per_objfile->die_type_hash =