X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fdwarf2read.c;h=ecfae68427716333ab060ef1c44b3a25df9d7ac0;hb=4b4477b52eee60ddadd59c36ffd778bbd9ab1c07;hp=5e71ded2039abb7f9326d9dc08cb1aa40a283175;hpb=fd3619828e94a24a92cddec42cbc0ab33352eeb4;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index 5e71ded203..ecfae68427 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -41,7 +41,6 @@ #include "buildsym.h" #include "demangle.h" #include "gdb-demangle.h" -#include "expression.h" #include "filenames.h" /* for DOSish file names */ #include "macrotab.h" #include "language.h" @@ -56,38 +55,26 @@ #include "addrmap.h" #include "typeprint.h" #include "psympriv.h" -#include -#include "completer.h" -#include "gdbsupport/vec.h" #include "c-lang.h" #include "go-lang.h" #include "valprint.h" #include "gdbcore.h" /* for gnutarget */ #include "gdb/gdb-index.h" -#include #include "gdb_bfd.h" #include "f-lang.h" #include "source.h" -#include "gdbsupport/filestuff.h" #include "build-id.h" #include "namespace.h" -#include "gdbsupport/gdb_unlinker.h" #include "gdbsupport/function-view.h" #include "gdbsupport/gdb_optional.h" #include "gdbsupport/underlying.h" -#include "gdbsupport/byte-vector.h" #include "gdbsupport/hash_enum.h" #include "filename-seen-cache.h" #include "producer.h" #include -#include #include -#include #include #include "gdbsupport/selftest.h" -#include -#include -#include #include "rust-lang.h" #include "gdbsupport/pathstuff.h" @@ -620,7 +607,7 @@ struct type_unit_group /* The TUs that share this DW_AT_stmt_list entry. This is added to while parsing type units to build partial symtabs, and is deleted afterwards and not used again. */ - VEC (sig_type_ptr) *tus; + std::vector *tus; /* The compunit symtab. Type units in a group needn't all be defined in the same source file, @@ -922,13 +909,13 @@ typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader, int has_children, void *data); -/* A 1-based directory index. This is a strong typedef to prevent - accidentally using a directory index as a 0-based index into an - array/vector. */ -enum class dir_index : unsigned int {}; +/* dir_index is 1-based in DWARF 4 and before, and is 0-based in DWARF 5 and + later. */ +typedef int dir_index; -/* Likewise, a 1-based file name index. */ -enum class file_name_index : unsigned int {}; +/* file_name_index is 1-based in DWARF 4 and before, and is 0-based in DWARF 5 + and later. */ +typedef int file_name_index; struct file_entry { @@ -980,32 +967,47 @@ struct line_header void add_file_name (const char *name, dir_index d_index, unsigned int mod_time, unsigned int length); - /* Return the include dir at INDEX (1-based). Returns NULL if INDEX - is out of bounds. */ + /* Return the include dir at INDEX (0-based in DWARF 5 and 1-based before). + Returns NULL if INDEX is out of bounds. */ const char *include_dir_at (dir_index index) const { - /* Convert directory index number (1-based) to vector index - (0-based). */ - size_t vec_index = to_underlying (index) - 1; - - if (vec_index >= include_dirs.size ()) + int vec_index; + if (version >= 5) + vec_index = index; + else + vec_index = index - 1; + if (vec_index < 0 || vec_index >= m_include_dirs.size ()) return NULL; - return include_dirs[vec_index]; + return m_include_dirs[vec_index]; } - /* Return the file name at INDEX (1-based). Returns NULL if INDEX - is out of bounds. */ - file_entry *file_name_at (file_name_index index) + bool is_valid_file_index (int file_index) { - /* Convert file name index number (1-based) to vector index - (0-based). */ - size_t vec_index = to_underlying (index) - 1; + if (version >= 5) + return 0 <= file_index && file_index < file_names_size (); + return 1 <= file_index && file_index <= file_names_size (); + } - if (vec_index >= file_names.size ()) + /* Return the file name at INDEX (0-based in DWARF 5 and 1-based before). + Returns NULL if INDEX is out of bounds. */ + file_entry *file_name_at (file_name_index index) + { + int vec_index; + if (version >= 5) + vec_index = index; + else + vec_index = index - 1; + if (vec_index < 0 || vec_index >= m_file_names.size ()) return NULL; - return &file_names[vec_index]; + return &m_file_names[vec_index]; } + /* The indexes are 0-based in DWARF 5 and 1-based in DWARF 4. Therefore, + this method should only be used to iterate through all file entries in an + index-agnostic manner. */ + std::vector &file_names () + { return m_file_names; } + /* Offset of line number information in .debug_line section. */ sect_offset sect_off {}; @@ -1028,16 +1030,23 @@ struct line_header element is standard_opcode_lengths[opcode_base - 1]. */ std::unique_ptr standard_opcode_lengths; - /* The include_directories table. Note these are observing - pointers. The memory is owned by debug_line_buffer. */ - std::vector include_dirs; - - /* The file_names table. */ - std::vector file_names; + int file_names_size () + { return m_file_names.size(); } /* The start and end of the statement program following this header. These point into dwarf2_per_objfile->line_buffer. */ const gdb_byte *statement_program_start {}, *statement_program_end {}; + + private: + /* The include_directories table. Note these are observing + pointers. The memory is owned by debug_line_buffer. */ + std::vector m_include_dirs; + + /* The file_names table. This is private because the meaning of indexes + differs among DWARF versions (The first valid index is 1 in DWARF 4 and + before, and is 0 in DWARF 5 and later). So the client should use + file_name_at method for access. */ + std::vector m_file_names; }; typedef std::unique_ptr line_header_up; @@ -1388,7 +1397,7 @@ struct field_info /* Number of fields (including baseclasses). */ int nfields = 0; - /* Set if the accesibility of one of the fields is not public. */ + /* Set if the accessibility of one of the fields is not public. */ int non_public_fields = 0; /* Member function fieldlist array, contains name of possibly overloaded @@ -1499,7 +1508,7 @@ struct cu_partial_die_info cu_partial_die_info (struct dwarf2_cu *cu, struct partial_die_info *pdi) : cu (cu), pdi (pdi) - { /* Nothhing. */ } + { /* Nothing. */ } private: cu_partial_die_info () = delete; @@ -1901,6 +1910,9 @@ static void process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile); static struct type *dwarf2_per_cu_addr_type (struct dwarf2_per_cu_data *per_cu); static struct type *dwarf2_per_cu_addr_sized_int_type (struct dwarf2_per_cu_data *per_cu, bool unsigned_p); +static struct type *dwarf2_per_cu_int_type + (struct dwarf2_per_cu_data *per_cu, int size_in_bytes, + bool unsigned_p); /* Class, the destructor of which frees all allocated queue entries. This will only have work to do if an error was thrown while processing the @@ -2138,8 +2150,10 @@ attr_value_as_address (struct attribute *attr) /* See declaration. */ dwarf2_per_objfile::dwarf2_per_objfile (struct objfile *objfile_, - const dwarf2_debug_sections *names) - : objfile (objfile_) + const dwarf2_debug_sections *names, + bool can_copy_) + : objfile (objfile_), + can_copy (can_copy_) { if (names == NULL) names = &dwarf2_elf_names; @@ -2162,10 +2176,10 @@ dwarf2_per_objfile::~dwarf2_per_objfile () htab_delete (line_header_hash); for (dwarf2_per_cu_data *per_cu : all_comp_units) - VEC_free (dwarf2_per_cu_ptr, per_cu->imported_symtabs); + per_cu->imported_symtabs_free (); for (signatured_type *sig_type : all_type_units) - VEC_free (dwarf2_per_cu_ptr, sig_type->per_cu.imported_symtabs); + sig_type->per_cu.imported_symtabs_free (); /* Everything else should be on the objfile obstack. */ } @@ -2214,11 +2228,14 @@ private: /* Try to locate the sections we need for DWARF 2 debugging information and return true if we have enough to do something. NAMES points to the dwarf2 section names, or is NULL if the standard - ELF names are used. */ + ELF names are used. CAN_COPY is true for formats where symbol + interposition is possible and so symbol values must follow copy + relocation rules. */ int dwarf2_has_info (struct objfile *objfile, - const struct dwarf2_debug_sections *names) + const struct dwarf2_debug_sections *names, + bool can_copy) { if (objfile->flags & OBJF_READNEVER) return 0; @@ -2228,7 +2245,8 @@ dwarf2_has_info (struct objfile *objfile, if (dwarf2_per_objfile == NULL) dwarf2_per_objfile = dwarf2_objfile_data_key.emplace (objfile, objfile, - names); + names, + can_copy); return (!dwarf2_per_objfile->info.is_virtual && dwarf2_per_objfile->info.s.section != NULL @@ -2345,6 +2363,15 @@ dwarf2_per_objfile::locate_sections (bfd *abfd, asection *sectp, if ((aflag & SEC_HAS_CONTENTS) == 0) { } + else if (elf_section_data (sectp)->this_hdr.sh_size + > bfd_get_file_size (abfd)) + { + bfd_size_type size = elf_section_data (sectp)->this_hdr.sh_size; + warning (_("Discarding section %s which has a section size (%s" + ") larger than the file size [in module %s]"), + bfd_section_name (sectp), phex_nz (size, sizeof (size)), + bfd_get_filename (abfd)); + } else if (section_is_p (sectp->name, &names.info)) { this->info.s.section = sectp; @@ -3584,14 +3611,14 @@ dwarf2_read_gdb_index return 0; if (!read_gdb_index_from_buffer (objfile, - bfd_get_filename (dwz->dwz_bfd), 1, - dwz_index_content, &dwz_map, + bfd_get_filename (dwz->dwz_bfd.get ()), + 1, dwz_index_content, &dwz_map, &dwz_list, &dwz_list_elements, &dwz_types_ignore, &dwz_types_elements_ignore)) { warning (_("could not read '.gdb_index' section from %s; skipping"), - bfd_get_filename (dwz->dwz_bfd)); + bfd_get_filename (dwz->dwz_bfd.get ())); return 0; } } @@ -3638,7 +3665,6 @@ dw2_get_file_names_reader (const struct die_reader_specs *reader, struct objfile *objfile = dwarf2_per_objfile->objfile; struct dwarf2_per_cu_data *lh_cu; struct attribute *attr; - int i; void **slot; struct quick_file_names *qfn; @@ -3659,7 +3685,7 @@ dw2_get_file_names_reader (const struct die_reader_specs *reader, sect_offset line_offset {}; attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu); - if (attr) + if (attr != nullptr) { struct quick_file_names find_entry; @@ -3697,12 +3723,12 @@ dw2_get_file_names_reader (const struct die_reader_specs *reader, if (strcmp (fnd.name, "") != 0) ++offset; - qfn->num_file_names = offset + lh->file_names.size (); + qfn->num_file_names = offset + lh->file_names_size (); qfn->file_names = XOBNEWVEC (&objfile->objfile_obstack, const char *, qfn->num_file_names); if (offset != 0) qfn->file_names[0] = xstrdup (fnd.name); - for (i = 0; i < lh->file_names.size (); ++i) + for (int i = 0; i < lh->file_names_size (); ++i) qfn->file_names[i + offset] = file_full_name (i + 1, lh.get (), fnd.comp_dir); qfn->real_names = NULL; @@ -4019,6 +4045,10 @@ dw2_symtab_iter_next (struct dw2_symtab_iterator *iter) if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER) continue; break; + case MODULE_DOMAIN: + if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER) + continue; + break; default: break; } @@ -5041,6 +5071,10 @@ dw2_expand_marked_cus if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE) continue; break; + case MODULES_DOMAIN: + if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER) + continue; + break; default: break; } @@ -5596,11 +5630,11 @@ dwarf2_read_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile) if (dwz != NULL) { if (!read_debug_names_from_section (objfile, - bfd_get_filename (dwz->dwz_bfd), + bfd_get_filename (dwz->dwz_bfd.get ()), &dwz->debug_names, dwz_map)) { warning (_("could not read '.debug_names' section from %s; skipping"), - bfd_get_filename (dwz->dwz_bfd)); + bfd_get_filename (dwz->dwz_bfd.get ())); return false; } } @@ -5947,6 +5981,15 @@ dw2_debug_names_iterator::next () goto again; } break; + case MODULE_DOMAIN: + switch (indexval.dwarf_tag) + { + case DW_TAG_module: + break; + default: + goto again; + } + break; default: break; } @@ -5983,6 +6026,14 @@ dw2_debug_names_iterator::next () goto again; } break; + case MODULES_DOMAIN: + switch (indexval.dwarf_tag) + { + case DW_TAG_module: + break; + default: + goto again; + } default: break; } @@ -6025,10 +6076,10 @@ dw2_debug_names_lookup_symbol (struct objfile *objfile, block_enum block_index, information (but NAME might contain it). */ if (sym != NULL - && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0) + && strcmp_iw (sym->search_name (), name) == 0) return stab; if (with_opaque != NULL - && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque), name) == 0) + && strcmp_iw (with_opaque->search_name (), name) == 0) stab_best = stab; /* Keep looking through other CUs. */ @@ -6371,7 +6422,7 @@ dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu) cu->base_address = 0; attr = dwarf2_attr (die, DW_AT_entry_pc, cu); - if (attr) + if (attr != nullptr) { cu->base_address = attr_value_as_address (attr); cu->base_known = 1; @@ -6379,7 +6430,7 @@ dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu) else { attr = dwarf2_attr (die, DW_AT_low_pc, cu); - if (attr) + if (attr != nullptr) { cu->base_address = attr_value_as_address (attr); cu->base_known = 1; @@ -6643,7 +6694,7 @@ dwarf2_build_include_psymtabs (struct dwarf2_cu *cu, struct attribute *attr; attr = dwarf2_attr (die, DW_AT_stmt_list, cu); - if (attr) + if (attr != nullptr) lh = dwarf_decode_line_header ((sect_offset) DW_UNSND (attr), cu); if (lh == NULL) return; /* No linetable, so no includes. */ @@ -7228,14 +7279,14 @@ read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu, or DW_FORM_addrx. */ cu->addr_base = 0; attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu); - if (attr) + if (attr != nullptr) cu->addr_base = DW_UNSND (attr); /* There should be a DW_AT_ranges_base attribute here (if needed). We need the value before we can process DW_AT_ranges. */ cu->ranges_base = 0; attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu); - if (attr) + if (attr != nullptr) cu->ranges_base = DW_UNSND (attr); } else if (stub_comp_dir != NULL) @@ -8086,24 +8137,23 @@ process_psymtab_comp_unit_reader (const struct die_reader_specs *reader, end_psymtab_common (objfile, pst); - if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs)) + if (!cu->per_cu->imported_symtabs_empty ()) { int i; - int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs); - struct dwarf2_per_cu_data *iter; + int len = cu->per_cu->imported_symtabs_size (); /* Fill in 'dependencies' here; we fill in 'users' in a post-pass. */ pst->number_of_dependencies = len; pst->dependencies = objfile->partial_symtabs->allocate_dependencies (len); - for (i = 0; - VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs, - i, iter); - ++i) - pst->dependencies[i] = iter->v.psymtab; + for (i = 0; i < len; ++i) + { + pst->dependencies[i] + = cu->per_cu->imported_symtabs->at (i)->v.psymtab; + } - VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs); + cu->per_cu->imported_symtabs_free (); } /* Get the list of files included in the current compilation unit, @@ -8184,7 +8234,9 @@ build_type_psymtabs_reader (const struct die_reader_specs *reader, attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list); tu_group = get_type_unit_group (cu, attr); - VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type); + if (tu_group->tus == nullptr) + tu_group->tus = new std::vector; + tu_group->tus->push_back (sig_type); prepare_one_comp_unit (cu, type_unit_die, language_minimal); pst = create_partial_symtab (per_cu, ""); @@ -8341,8 +8393,7 @@ build_type_psymtab_dependencies (void **slot, void *info) struct type_unit_group *tu_group = (struct type_unit_group *) *slot; struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu; struct partial_symtab *pst = per_cu->v.psymtab; - int len = VEC_length (sig_type_ptr, tu_group->tus); - struct signatured_type *iter; + int len = (tu_group->tus == nullptr) ? 0 : tu_group->tus->size (); int i; gdb_assert (len > 0); @@ -8350,16 +8401,16 @@ build_type_psymtab_dependencies (void **slot, void *info) pst->number_of_dependencies = len; pst->dependencies = objfile->partial_symtabs->allocate_dependencies (len); - for (i = 0; - VEC_iterate (sig_type_ptr, tu_group->tus, i, iter); - ++i) + for (i = 0; i < len; ++i) { + struct signatured_type *iter = tu_group->tus->at (i); gdb_assert (iter->per_cu.is_debug_types); pst->dependencies[i] = iter->per_cu.v.psymtab; iter->type_unit_group = tu_group; } - VEC_free (sig_type_ptr, tu_group->tus); + delete tu_group->tus; + tu_group->tus = nullptr; return 1; } @@ -8710,7 +8761,8 @@ scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc, add_partial_namespace (pdi, lowpc, highpc, set_addrmap, cu); break; case DW_TAG_module: - add_partial_module (pdi, lowpc, highpc, set_addrmap, cu); + if (!pdi->is_declaration) + add_partial_module (pdi, lowpc, highpc, set_addrmap, cu); break; case DW_TAG_imported_unit: { @@ -8732,8 +8784,7 @@ scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc, if (per_cu->v.psymtab == NULL) process_psymtab_comp_unit (per_cu, 1, cu->language); - VEC_safe_push (dwarf2_per_cu_ptr, - cu->per_cu->imported_symtabs, per_cu); + cu->per_cu->imported_symtabs_push (per_cu); } break; case DW_TAG_imported_declaration: @@ -8816,6 +8867,7 @@ partial_die_parent_scope (struct partial_die_info *pdi, return NULL; } + /* Nested subroutines in Fortran get a prefix. */ if (pdi->tag == DW_TAG_enumerator) /* Enumerators should not get the name of the enumeration as a prefix. */ parent->scope = grandparent_scope; @@ -8825,7 +8877,10 @@ partial_die_parent_scope (struct partial_die_info *pdi, || parent->tag == DW_TAG_class_type || parent->tag == DW_TAG_interface_type || parent->tag == DW_TAG_union_type - || parent->tag == DW_TAG_enumeration_type) + || parent->tag == DW_TAG_enumeration_type + || (cu->language == language_fortran + && parent->tag == DW_TAG_subprogram + && pdi->tag == DW_TAG_subprogram)) { if (grandparent_scope == NULL) parent->scope = parent->name; @@ -8916,13 +8971,17 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) case DW_TAG_subprogram: addr = (gdbarch_adjust_dwarf2_addr (gdbarch, pdi->lowpc + baseaddr) - baseaddr); - if (pdi->is_external || cu->language == language_ada) - { - /* brobecker/2007-12-26: Normally, only "external" DIEs are part - of the global scope. But in Ada, we want to be able to access - nested procedures globally. So all Ada subprograms are stored - in the global scope. */ - add_psymbol_to_list (actual_name, strlen (actual_name), + if (pdi->is_external + || cu->language == language_ada + || (cu->language == language_fortran + && pdi->die_parent != NULL + && pdi->die_parent->tag == DW_TAG_subprogram)) + { + /* Normally, only "external" DIEs are part of the global scope. + But in Ada and Fortran, we want to be able to access nested + procedures globally. So all Ada and Fortran subprograms are + stored in the global scope. */ + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_BLOCK, SECT_OFF_TEXT (objfile), @@ -8932,7 +8991,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) } else { - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_BLOCK, SECT_OFF_TEXT (objfile), @@ -8944,7 +9003,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) set_objfile_main_name (objfile, actual_name, cu->language); break; case DW_TAG_constant: - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC, -1, (pdi->is_external ? psymbol_placement::GLOBAL @@ -8980,7 +9039,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) table building. */ if (pdi->d.locdesc || pdi->has_type) - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC, SECT_OFF_TEXT (objfile), @@ -8999,7 +9058,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) return; } - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC, SECT_OFF_TEXT (objfile), @@ -9011,7 +9070,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) case DW_TAG_typedef: case DW_TAG_base_type: case DW_TAG_subrange_type: - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::STATIC, @@ -9019,7 +9078,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) break; case DW_TAG_imported_declaration: case DW_TAG_namespace: - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::GLOBAL, @@ -9030,7 +9089,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) available without any name. If so, we skip the module as it doesn't bring any value. */ if (actual_name != nullptr) - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, MODULE_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::GLOBAL, @@ -9054,7 +9113,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) /* NOTE: carlton/2003-10-07: See comment in new_symbol about static vs. global. */ - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, STRUCT_DOMAIN, LOC_TYPEDEF, -1, cu->language == language_cplus @@ -9064,7 +9123,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) break; case DW_TAG_enumerator: - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_CONST, -1, cu->language == language_cplus @@ -9177,7 +9236,7 @@ add_partial_subprogram (struct partial_die_info *pdi, if (! pdi->has_children) return; - if (cu->language == language_ada) + if (cu->language == language_ada || cu->language == language_fortran) { pdi = pdi->die_child; while (pdi != NULL) @@ -9336,6 +9395,7 @@ skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr, case DW_FORM_data1: case DW_FORM_ref1: case DW_FORM_flag: + case DW_FORM_strx1: info_ptr += 1; break; case DW_FORM_flag_present: @@ -9343,10 +9403,15 @@ skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr, break; case DW_FORM_data2: case DW_FORM_ref2: + case DW_FORM_strx2: info_ptr += 2; break; + case DW_FORM_strx3: + info_ptr += 3; + break; case DW_FORM_data4: case DW_FORM_ref4: + case DW_FORM_strx4: info_ptr += 4; break; case DW_FORM_data8: @@ -9851,7 +9916,7 @@ fixup_go_packaging (struct dwarf2_cu *cu) { struct symbol *sym = list->symbol[i]; - if (SYMBOL_LANGUAGE (sym) == language_go + if (sym->language () == language_go && SYMBOL_CLASS (sym) == LOC_BLOCK) { char *this_package_name = go_symbol_package_name (sym); @@ -9887,9 +9952,8 @@ fixup_go_packaging (struct dwarf2_cu *cu) struct symbol *sym; sym = allocate_symbol (objfile); - SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack); - SYMBOL_SET_NAMES (sym, saved_package_name, - strlen (saved_package_name), 0, objfile); + sym->set_language (language_go, &objfile->objfile_obstack); + SYMBOL_SET_NAMES (sym, saved_package_name, false, objfile); /* This is not VAR_DOMAIN because we want a way to ensure a lookup of, e.g., "main" finds the "main" module and not C's main(). */ SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN; @@ -10055,10 +10119,10 @@ quirk_rust_enum (struct type *type, struct objfile *objfile) SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0); TYPE_FIELD_NAME (type, 0) = "<>"; } - else if (TYPE_NFIELDS (type) == 1) + /* A union with a single anonymous field is probably an old-style + univariant enum. */ + else if (TYPE_NFIELDS (type) == 1 && streq (TYPE_FIELD_NAME (type, 0), "")) { - /* We assume that a union with a single field is a univariant - enum. */ /* Smash this type to be a structure type. We have to do this because the type has already been recorded. */ TYPE_CODE (type) = TYPE_CODE_STRUCT; @@ -10235,9 +10299,7 @@ recursively_compute_inclusions (std::vector *result, struct compunit_symtab *immediate_parent) { void **slot; - int ix; struct compunit_symtab *cust; - struct dwarf2_per_cu_data *iter; slot = htab_find_slot (all_children, per_cu, INSERT); if (*slot != NULL) @@ -10272,13 +10334,12 @@ recursively_compute_inclusions (std::vector *result, } } - for (ix = 0; - VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter); - ++ix) - { - recursively_compute_inclusions (result, all_children, - all_type_symtabs, iter, cust); - } + if (!per_cu->imported_symtabs_empty ()) + for (dwarf2_per_cu_data *ptr : *per_cu->imported_symtabs) + { + recursively_compute_inclusions (result, all_children, + all_type_symtabs, ptr, cust); + } } /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of @@ -10289,10 +10350,9 @@ compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu) { gdb_assert (! per_cu->is_debug_types); - if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs)) + if (!per_cu->imported_symtabs_empty ()) { - int ix, len; - struct dwarf2_per_cu_data *per_cu_iter; + int len; std::vector result_symtabs; htab_t all_children, all_type_symtabs; struct compunit_symtab *cust = get_compunit_symtab (per_cu); @@ -10306,14 +10366,10 @@ compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu) all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer, NULL, xcalloc, xfree); - for (ix = 0; - VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, - ix, per_cu_iter); - ++ix) + for (dwarf2_per_cu_data *ptr : *per_cu->imported_symtabs) { recursively_compute_inclusions (&result_symtabs, all_children, - all_type_symtabs, per_cu_iter, - cust); + all_type_symtabs, ptr, cust); } /* Now we have a transitive closure of all the included symtabs. */ @@ -10377,7 +10433,7 @@ process_full_comp_unit (struct dwarf2_per_cu_data *per_cu, if (cu->language == language_go) fixup_go_packaging (cu); - /* Now that we have processed all the DIEs in the CU, all the types + /* Now that we have processed all the DIEs in the CU, all the types should be complete, and it should now be safe to compute all of the physnames. */ compute_delayed_physnames (cu); @@ -10426,7 +10482,7 @@ process_full_comp_unit (struct dwarf2_per_cu_data *per_cu, Still one can confuse GDB by using non-standard GCC compilation options - this waits on GCC PR other/32998 (-frecord-gcc-switches). - */ + */ if (cu->has_loclist && gcc_4_minor >= 5) cust->locations_valid = 1; @@ -10481,7 +10537,7 @@ process_full_type_unit (struct dwarf2_per_cu_data *per_cu, if (cu->language == language_go) fixup_go_packaging (cu); - /* Now that we have processed all the DIEs in the CU, all the types + /* Now that we have processed all the DIEs in the CU, all the types should be complete, and it should now be safe to compute all of the physnames. */ compute_delayed_physnames (cu); @@ -10557,8 +10613,7 @@ process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu) if (maybe_queue_comp_unit (cu, per_cu, cu->language)) load_full_comp_unit (per_cu, false, cu->language); - VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs, - per_cu); + cu->per_cu->imported_symtabs_push (per_cu); } } @@ -10613,6 +10668,12 @@ process_die (struct die_info *die, struct dwarf2_cu *cu) read_type_unit_scope (die, cu); break; case DW_TAG_subprogram: + /* Nested subprograms in Fortran get a prefix. */ + if (cu->language == language_fortran + && die->parent != NULL + && die->parent->tag == DW_TAG_subprogram) + cu->processing_has_namespace_info = true; + /* Fall through. */ case DW_TAG_inlined_subroutine: read_func_scope (die, cu); break; @@ -11690,14 +11751,14 @@ dwarf2_cu::setup_type_unit_groups (struct die_info *die) process_full_type_unit still needs to know if this is the first time. */ - tu_group->num_symtabs = line_header->file_names.size (); + tu_group->num_symtabs = line_header->file_names_size (); tu_group->symtabs = XNEWVEC (struct symtab *, - line_header->file_names.size ()); + line_header->file_names_size ()); - for (i = 0; i < line_header->file_names.size (); ++i) + auto &file_names = line_header->file_names (); + for (i = 0; i < file_names.size (); ++i) { - file_entry &fe = line_header->file_names[i]; - + file_entry &fe = file_names[i]; dwarf2_start_subfile (this, fe.name, fe.include_dir (line_header)); buildsym_compunit *b = get_builder (); @@ -11726,10 +11787,10 @@ dwarf2_cu::setup_type_unit_groups (struct die_info *die) compunit_language (cust), 0, cust)); - for (i = 0; i < line_header->file_names.size (); ++i) + auto &file_names = line_header->file_names (); + for (i = 0; i < file_names.size (); ++i) { - file_entry &fe = line_header->file_names[i]; - + file_entry &fe = file_names[i]; fe.symtab = tu_group->symtabs[i]; } } @@ -13484,7 +13545,7 @@ queue_and_load_dwo_tu (void **slot, void *info) while processing PER_CU. */ if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language)) load_full_type_unit (sig_cu); - VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu); + per_cu->imported_symtabs_push (sig_cu); } return 1; @@ -13639,6 +13700,9 @@ inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu) origin_child_die = sibling_die (origin_child_die); } origin_cu->list_in_scope = origin_previous_list_in_scope; + + if (cu != origin_cu) + compute_delayed_physnames (origin_cu); } static void @@ -13718,19 +13782,19 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu) (struct symbol *) templ_func); if (dwarf2_flag_true_p (die, DW_AT_main_subprogram, cu)) - set_objfile_main_name (objfile, SYMBOL_LINKAGE_NAME (newobj->name), + set_objfile_main_name (objfile, newobj->name->linkage_name (), cu->language); /* If there is a location expression for DW_AT_frame_base, record it. */ attr = dwarf2_attr (die, DW_AT_frame_base, cu); - if (attr) + if (attr != nullptr) dwarf2_symbol_mark_computed (attr, newobj->name, cu, 1); /* If there is a location for the static link, record it. */ newobj->static_link = NULL; attr = dwarf2_attr (die, DW_AT_static_link, cu); - if (attr) + if (attr != nullptr) { newobj->static_link = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop); @@ -14206,7 +14270,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) attr = dwarf2_attr (child_die, DW_AT_call_data_value, cu); if (attr == NULL) attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu); - if (attr) + if (attr != nullptr) { if (!attr_form_is_block (attr)) complaint (_("No DW_FORM_block* DW_AT_call_data_value for " @@ -14262,8 +14326,7 @@ read_variable (struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile; - storage = OBSTACK_ZALLOC (&objfile->objfile_obstack, - struct rust_vtable_symbol); + storage = new (&objfile->objfile_obstack) rust_vtable_symbol (); initialize_objfile_symbol (storage); storage->concrete_type = containing_type; storage->subclass = SYMBOL_RUST_VTABLE; @@ -14648,7 +14711,7 @@ dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc, if (attr_high) { attr = dwarf2_attr (die, DW_AT_low_pc, cu); - if (attr) + if (attr != nullptr) { low = attr_value_as_address (attr); high = attr_value_as_address (attr_high); @@ -14821,7 +14884,7 @@ dwarf2_record_block_ranges (struct die_info *die, struct block *block, if (attr_high) { attr = dwarf2_attr (die, DW_AT_low_pc, cu); - if (attr) + if (attr != nullptr) { CORE_ADDR low = attr_value_as_address (attr); CORE_ADDR high = attr_value_as_address (attr_high); @@ -14836,7 +14899,7 @@ dwarf2_record_block_ranges (struct die_info *die, struct block *block, } attr = dwarf2_attr (die, DW_AT_ranges, cu); - if (attr) + if (attr != nullptr) { /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton. We take advantage of the fact that DW_AT_ranges does not appear @@ -14930,7 +14993,7 @@ producer_is_codewarrior (struct dwarf2_cu *cu) return cu->producer_is_codewarrior; } -/* Return the default accessibility type if it is not overriden by +/* Return the default accessibility type if it is not overridden by DW_AT_accessibility. */ static enum dwarf_access_attribute @@ -15021,7 +15084,7 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die, fip->nfields++; attr = dwarf2_attr (die, DW_AT_accessibility, cu); - if (attr) + if (attr != nullptr) new_field->accessibility = DW_UNSND (attr); else new_field->accessibility = dwarf2_default_access_attribute (die, cu); @@ -15029,7 +15092,7 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die, fip->non_public_fields = 1; attr = dwarf2_attr (die, DW_AT_virtuality, cu); - if (attr) + if (attr != nullptr) new_field->virtuality = DW_UNSND (attr); else new_field->virtuality = DW_VIRTUALITY_none; @@ -15049,7 +15112,7 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die, /* Get bit size of field (zero if none). */ attr = dwarf2_attr (die, DW_AT_bit_size, cu); - if (attr) + if (attr != nullptr) { FIELD_BITSIZE (*fp) = DW_UNSND (attr); } @@ -15062,9 +15125,9 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die, if (handle_data_member_location (die, cu, &offset)) SET_FIELD_BITPOS (*fp, offset * bits_per_byte); attr = dwarf2_attr (die, DW_AT_bit_offset, cu); - if (attr) + if (attr != nullptr) { - if (gdbarch_bits_big_endian (gdbarch)) + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) { /* For big endian bits, the DW_AT_bit_offset gives the additional bit offset from the MSB of the containing @@ -15085,7 +15148,7 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die, int bit_offset = DW_UNSND (attr); attr = dwarf2_attr (die, DW_AT_byte_size, cu); - if (attr) + if (attr != nullptr) { /* The size of the anonymous object containing the bit field is explicit, so use the @@ -15192,13 +15255,18 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die, /* Normally a DW_TAG_variant_part won't have a size, but our representation requires one, so set it to the maximum of the - child sizes. */ + child sizes, being sure to account for the offset at which + each child is seen. */ if (TYPE_LENGTH (fp->type) == 0) { unsigned max = 0; for (int i = 0; i < TYPE_NFIELDS (fp->type); ++i) - if (TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i)) > max) - max = TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i)); + { + unsigned len = ((TYPE_FIELD_BITPOS (fp->type, i) + 7) / 8 + + TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i))); + if (len > max) + max = len; + } TYPE_LENGTH (fp->type) = max; } } @@ -15497,7 +15565,7 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die, /* Get accessibility. */ attr = dwarf2_attr (die, DW_AT_accessibility, cu); - if (attr) + if (attr != nullptr) accessibility = (enum dwarf_access_attribute) DW_UNSND (attr); else accessibility = dwarf2_default_access_attribute (die, cu); @@ -15525,7 +15593,7 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die, to the object address. */ attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu); - if (attr) + if (attr != nullptr) { if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0) { @@ -15779,7 +15847,7 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu) Don't follow DW_AT_specification though, that will take us back up the chain and we want to go down. */ attr = dwarf2_attr_no_follow (die, DW_AT_signature); - if (attr) + if (attr != nullptr) { type = get_DW_AT_signature_type (die, attr, cu); @@ -15837,7 +15905,7 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu) TYPE_DECLARED_CLASS (type) = 1; attr = dwarf2_attr (die, DW_AT_byte_size, cu); - if (attr) + if (attr != nullptr) { if (attr_form_is_constant (attr)) TYPE_LENGTH (type) = DW_UNSND (attr); @@ -15992,7 +16060,7 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) read the discriminant member, so we can record it later in the discriminant_info. */ bool is_variant_part = TYPE_FLAG_DISCRIMINATED_UNION (type); - sect_offset discr_offset; + sect_offset discr_offset {}; bool has_template_parameters = false; if (is_variant_part) @@ -16203,7 +16271,7 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) { /* Any related symtab will do. */ symtab - = cu->line_header->file_name_at (file_name_index (1))->symtab; + = cu->line_header->file_names ()[0].symtab; } else { @@ -16303,7 +16371,7 @@ read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu) Don't follow DW_AT_specification though, that will take us back up the chain and we want to go down. */ attr = dwarf2_attr_no_follow (die, DW_AT_signature); - if (attr) + if (attr != nullptr) { type = get_DW_AT_signature_type (die, attr, cu); @@ -16328,7 +16396,7 @@ read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu) } attr = dwarf2_attr (die, DW_AT_byte_size, cu); - if (attr) + if (attr != nullptr) { TYPE_LENGTH (type) = DW_UNSND (attr); } @@ -16419,7 +16487,7 @@ process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu) * sizeof (struct field)); } - FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym); + FIELD_NAME (fields[num_fields]) = sym->linkage_name (); FIELD_TYPE (fields[num_fields]) = NULL; SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym)); FIELD_BITSIZE (fields[num_fields]) = 0; @@ -16572,14 +16640,14 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu) array and the vector variant is that vectors are passed by value to functions. */ attr = dwarf2_attr (die, DW_AT_GNU_vector, cu); - if (attr) + if (attr != nullptr) make_vector_type (type); /* The DIE may have DW_AT_byte_size set. For example an OpenCL implementation may choose to implement triple vectors using this attribute. */ attr = dwarf2_attr (die, DW_AT_byte_size, cu); - if (attr) + if (attr != nullptr) { if (DW_UNSND (attr) >= TYPE_LENGTH (type)) TYPE_LENGTH (type) = DW_UNSND (attr); @@ -16610,7 +16678,7 @@ read_array_order (struct die_info *die, struct dwarf2_cu *cu) attr = dwarf2_attr (die, DW_AT_ordering, cu); - if (attr) + if (attr != nullptr) return (enum dwarf_array_dim_ordering) DW_SND (attr); /* GNU F77 is a special case, as at 08/2004 array type info is the @@ -16655,7 +16723,7 @@ read_set_type (struct die_info *die, struct dwarf2_cu *cu) set_type = create_set_type (NULL, domain_type); attr = dwarf2_attr (die, DW_AT_byte_size, cu); - if (attr) + if (attr != nullptr) TYPE_LENGTH (set_type) = DW_UNSND (attr); maybe_set_alignment (cu, die, set_type); @@ -16739,7 +16807,7 @@ mark_common_block_symbol_computed (struct symbol *sym, /* Create appropriate locally-scoped variables for all the DW_TAG_common_block entries. Also create a struct common_block listing all such variables for `info common'. COMMON_BLOCK_DOMAIN - is used to sepate the common blocks name namespace from regular + is used to separate the common blocks name namespace from regular variable names. */ static void @@ -16748,7 +16816,7 @@ read_common_block (struct die_info *die, struct dwarf2_cu *cu) struct attribute *attr; attr = dwarf2_attr (die, DW_AT_location, cu); - if (attr) + if (attr != nullptr) { /* Support the .debug_loc offsets. */ if (attr_form_is_block (attr)) @@ -16821,7 +16889,7 @@ read_common_block (struct die_info *die, struct dwarf2_cu *cu) else if (attr_form_is_constant (member_loc) || attr_form_is_block (member_loc)) { - if (attr) + if (attr != nullptr) mark_common_block_symbol_computed (sym, die, attr, member_loc, cu); } @@ -17122,7 +17190,7 @@ read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu, type = lookup_reference_type (target_type, refcode); attr = dwarf2_attr (die, DW_AT_byte_size, cu); - if (attr) + if (attr != nullptr) { TYPE_LENGTH (type) = DW_UNSND (attr); } @@ -17255,29 +17323,90 @@ read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu) struct gdbarch *gdbarch = get_objfile_arch (objfile); struct type *type, *range_type, *index_type, *char_type; struct attribute *attr; - unsigned int length; + struct dynamic_prop prop; + bool length_is_constant = true; + LONGEST length; + + /* There are a couple of places where bit sizes might be made use of + when parsing a DW_TAG_string_type, however, no producer that we know + of make use of these. Handling bit sizes that are a multiple of the + byte size is easy enough, but what about other bit sizes? Lets deal + with that problem when we have to. Warn about these attributes being + unsupported, then parse the type and ignore them like we always + have. */ + if (dwarf2_attr (die, DW_AT_bit_size, cu) != nullptr + || dwarf2_attr (die, DW_AT_string_length_bit_size, cu) != nullptr) + { + static bool warning_printed = false; + if (!warning_printed) + { + warning (_("DW_AT_bit_size and DW_AT_string_length_bit_size not " + "currently supported on DW_TAG_string_type.")); + warning_printed = true; + } + } attr = dwarf2_attr (die, DW_AT_string_length, cu); - if (attr) + if (attr != nullptr && !attr_form_is_constant (attr)) + { + /* The string length describes the location at which the length of + the string can be found. The size of the length field can be + specified with one of the attributes below. */ + struct type *prop_type; + struct attribute *len + = dwarf2_attr (die, DW_AT_string_length_byte_size, cu); + if (len == nullptr) + len = dwarf2_attr (die, DW_AT_byte_size, cu); + if (len != nullptr && attr_form_is_constant (len)) + { + /* Pass 0 as the default as we know this attribute is constant + and the default value will not be returned. */ + LONGEST sz = dwarf2_get_attr_constant_value (len, 0); + prop_type = dwarf2_per_cu_int_type (cu->per_cu, sz, true); + } + else + { + /* If the size is not specified then we assume it is the size of + an address on this target. */ + prop_type = dwarf2_per_cu_addr_sized_int_type (cu->per_cu, true); + } + + /* Convert the attribute into a dynamic property. */ + if (!attr_to_dynamic_prop (attr, die, cu, &prop, prop_type)) + length = 1; + else + length_is_constant = false; + } + else if (attr != nullptr) { - length = DW_UNSND (attr); + /* This DW_AT_string_length just contains the length with no + indirection. There's no need to create a dynamic property in this + case. Pass 0 for the default value as we know it will not be + returned in this case. */ + length = dwarf2_get_attr_constant_value (attr, 0); + } + else if ((attr = dwarf2_attr (die, DW_AT_byte_size, cu)) != nullptr) + { + /* We don't currently support non-constant byte sizes for strings. */ + length = dwarf2_get_attr_constant_value (attr, 1); } else { - /* Check for the DW_AT_byte_size attribute. */ - attr = dwarf2_attr (die, DW_AT_byte_size, cu); - if (attr) - { - length = DW_UNSND (attr); - } - else - { - length = 1; - } + /* Use 1 as a fallback length if we have nothing else. */ + length = 1; } index_type = objfile_type (objfile)->builtin_int; - range_type = create_static_range_type (NULL, index_type, 1, length); + if (length_is_constant) + range_type = create_static_range_type (NULL, index_type, 1, length); + else + { + struct dynamic_prop low_bound; + + low_bound.kind = PROP_CONST; + low_bound.data.const_val = 1; + range_type = create_range_type (NULL, index_type, &low_bound, &prop, 0); + } char_type = language_string_char_type (cu->language_defn, gdbarch); type = create_string_type (NULL, char_type, range_type); @@ -17297,7 +17426,7 @@ prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu) return 1; /* The DWARF standard implies that the DW_AT_prototyped attribute - is only meaninful for C, but the concept also extends to other + is only meaningful for C, but the concept also extends to other languages that allow unprototyped functions (Eg: Objective C). For all other languages, assume that functions are always prototyped. */ @@ -17350,7 +17479,7 @@ read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu) the subroutine die. Otherwise set the calling convention to the default value DW_CC_normal. */ attr = dwarf2_attr (die, DW_AT_calling_convention, cu); - if (attr) + if (attr != nullptr) TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr); else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL")) TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL; @@ -17416,7 +17545,7 @@ read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu) DWARF version 3 added DW_AT_object_pointer, which GCC 4.5 does not yet generate. */ attr = dwarf2_attr (child_die, DW_AT_artificial, cu); - if (attr) + if (attr != nullptr) TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr); else TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0; @@ -17433,7 +17562,7 @@ read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu) const char *name = dwarf2_name (child_die, cu); attr = dwarf2_attr (die, DW_AT_object_pointer, cu); - if (attr) + if (attr != nullptr) { /* If the compiler emits this, use it. */ if (follow_die_ref (die, attr, &arg_cu) == child_die) @@ -17495,7 +17624,7 @@ read_typedef (struct die_info *die, struct dwarf2_cu *cu) static struct type * dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name, - const char *name_hint) + const char *name_hint, enum bfd_endian byte_order) { struct gdbarch *gdbarch = get_objfile_arch (objfile); const struct floatformat **format; @@ -17503,7 +17632,7 @@ dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name, format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits); if (format) - type = init_float_type (objfile, bits, name, format); + type = init_float_type (objfile, bits, name, format, byte_order); else type = init_type (objfile, TYPE_CODE_ERROR, bits, name); @@ -17542,7 +17671,8 @@ dwarf2_init_integer_type (struct dwarf2_cu *cu, struct objfile *objfile, static struct type * dwarf2_init_complex_target_type (struct dwarf2_cu *cu, struct objfile *objfile, - int bits, const char *name_hint) + int bits, const char *name_hint, + enum bfd_endian byte_order) { gdbarch *gdbarch = get_objfile_arch (objfile); struct type *tt = nullptr; @@ -17591,7 +17721,7 @@ dwarf2_init_complex_target_type (struct dwarf2_cu *cu, tt = nullptr; const char *name = (tt == nullptr) ? nullptr : TYPE_NAME (tt); - return dwarf2_init_float_type (objfile, bits, name, name_hint); + return dwarf2_init_float_type (objfile, bits, name, name_hint, byte_order); } /* Find a representation of a given base type and install @@ -17605,21 +17735,38 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu) struct attribute *attr; int encoding = 0, bits = 0; const char *name; + gdbarch *arch; attr = dwarf2_attr (die, DW_AT_encoding, cu); - if (attr) - { - encoding = DW_UNSND (attr); - } + if (attr != nullptr) + encoding = DW_UNSND (attr); attr = dwarf2_attr (die, DW_AT_byte_size, cu); - if (attr) - { - bits = DW_UNSND (attr) * TARGET_CHAR_BIT; - } + if (attr != nullptr) + bits = DW_UNSND (attr) * TARGET_CHAR_BIT; name = dwarf2_name (die, cu); if (!name) + complaint (_("DW_AT_name missing from DW_TAG_base_type")); + + arch = get_objfile_arch (objfile); + enum bfd_endian byte_order = gdbarch_byte_order (arch); + + attr = dwarf2_attr (die, DW_AT_endianity, cu); + if (attr) { - complaint (_("DW_AT_name missing from DW_TAG_base_type")); + int endianity = DW_UNSND (attr); + + switch (endianity) + { + case DW_END_big: + byte_order = BFD_ENDIAN_BIG; + break; + case DW_END_little: + byte_order = BFD_ENDIAN_LITTLE; + break; + default: + complaint (_("DW_AT_endianity has unrecognized value %d"), endianity); + break; + } } switch (encoding) @@ -17633,14 +17780,15 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu) type = init_boolean_type (objfile, bits, 1, name); break; case DW_ATE_complex_float: - type = dwarf2_init_complex_target_type (cu, objfile, bits / 2, name); + type = dwarf2_init_complex_target_type (cu, objfile, bits / 2, name, + byte_order); type = init_complex_type (objfile, name, type); break; case DW_ATE_decimal_float: type = init_decfloat_type (objfile, bits, name); break; case DW_ATE_float: - type = dwarf2_init_float_type (objfile, bits, name, name); + type = dwarf2_init_float_type (objfile, bits, name, name, byte_order); break; case DW_ATE_signed: type = dwarf2_init_integer_type (cu, objfile, bits, 0, name); @@ -17672,8 +17820,6 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu) break; case DW_ATE_UTF: { - gdbarch *arch = get_objfile_arch (objfile); - if (bits == 16) type = builtin_type (arch)->builtin_char16; else if (bits == 32) @@ -17700,6 +17846,8 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu) maybe_set_alignment (cu, die, type); + TYPE_ENDIANITY_NOT_DEFAULT (type) = gdbarch_byte_order (arch) != byte_order; + return set_die_type (die, type, cu); } @@ -17728,7 +17876,15 @@ attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die, baton->locexpr.per_cu = cu->per_cu; baton->locexpr.size = DW_BLOCK (attr)->size; baton->locexpr.data = DW_BLOCK (attr)->data; - baton->locexpr.is_reference = false; + switch (attr->name) + { + case DW_AT_string_length: + baton->locexpr.is_reference = true; + break; + default: + baton->locexpr.is_reference = false; + break; + } prop->data.baton = baton; prop->kind = PROP_LOCEXPR; gdb_assert (prop->data.baton != NULL); @@ -17812,24 +17968,22 @@ attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die, return 1; } -/* Find an integer type the same size as the address size given in the - compilation unit header for PER_CU. UNSIGNED_P controls if the integer - is unsigned or not. */ +/* Find an integer type SIZE_IN_BYTES bytes in size and return it. + UNSIGNED_P controls if the integer is unsigned or not. */ static struct type * -dwarf2_per_cu_addr_sized_int_type (struct dwarf2_per_cu_data *per_cu, - bool unsigned_p) +dwarf2_per_cu_int_type (struct dwarf2_per_cu_data *per_cu, + int size_in_bytes, bool unsigned_p) { struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile; - int addr_size = dwarf2_per_cu_addr_size (per_cu); struct type *int_type; /* Helper macro to examine the various builtin types. */ -#define TRY_TYPE(F) \ - int_type = (unsigned_p \ - ? objfile_type (objfile)->builtin_unsigned_ ## F \ - : objfile_type (objfile)->builtin_ ## F); \ - if (int_type != NULL && TYPE_LENGTH (int_type) == addr_size) \ +#define TRY_TYPE(F) \ + int_type = (unsigned_p \ + ? objfile_type (objfile)->builtin_unsigned_ ## F \ + : objfile_type (objfile)->builtin_ ## F); \ + if (int_type != NULL && TYPE_LENGTH (int_type) == size_in_bytes) \ return int_type TRY_TYPE (char); @@ -17843,6 +17997,18 @@ dwarf2_per_cu_addr_sized_int_type (struct dwarf2_per_cu_data *per_cu, gdb_assert_not_reached ("unable to find suitable integer type"); } +/* Find an integer type the same size as the address size given in the + compilation unit header for PER_CU. UNSIGNED_P controls if the integer + is unsigned or not. */ + +static struct type * +dwarf2_per_cu_addr_sized_int_type (struct dwarf2_per_cu_data *per_cu, + bool unsigned_p) +{ + int addr_size = dwarf2_per_cu_addr_size (per_cu); + return dwarf2_per_cu_int_type (per_cu, addr_size, unsigned_p); +} + /* Read the DW_AT_type attribute for a sub-range. If this attribute is not present (which is valid) then compute the default type based on the compilation units address size. */ @@ -17933,7 +18099,7 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu) } attr = dwarf2_attr (die, DW_AT_lower_bound, cu); - if (attr) + if (attr != nullptr) attr_to_dynamic_prop (attr, die, cu, &low, base_type); else if (!low_default_is_valid) complaint (_("Missing DW_AT_lower_bound " @@ -17990,7 +18156,52 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu) && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask)) high.data.const_val |= negative_mask; - range_type = create_range_type (NULL, orig_base_type, &low, &high, bias); + /* Check for bit and byte strides. */ + struct dynamic_prop byte_stride_prop; + attribute *attr_byte_stride = dwarf2_attr (die, DW_AT_byte_stride, cu); + if (attr_byte_stride != nullptr) + { + struct type *prop_type + = dwarf2_per_cu_addr_sized_int_type (cu->per_cu, false); + attr_to_dynamic_prop (attr_byte_stride, die, cu, &byte_stride_prop, + prop_type); + } + + struct dynamic_prop bit_stride_prop; + attribute *attr_bit_stride = dwarf2_attr (die, DW_AT_bit_stride, cu); + if (attr_bit_stride != nullptr) + { + /* It only makes sense to have either a bit or byte stride. */ + if (attr_byte_stride != nullptr) + { + complaint (_("Found DW_AT_bit_stride and DW_AT_byte_stride " + "- DIE at %s [in module %s]"), + sect_offset_str (die->sect_off), + objfile_name (cu->per_cu->dwarf2_per_objfile->objfile)); + attr_bit_stride = nullptr; + } + else + { + struct type *prop_type + = dwarf2_per_cu_addr_sized_int_type (cu->per_cu, false); + attr_to_dynamic_prop (attr_bit_stride, die, cu, &bit_stride_prop, + prop_type); + } + } + + if (attr_byte_stride != nullptr + || attr_bit_stride != nullptr) + { + bool byte_stride_p = (attr_byte_stride != nullptr); + struct dynamic_prop *stride + = byte_stride_p ? &byte_stride_prop : &bit_stride_prop; + + range_type + = create_range_type_with_stride (NULL, orig_base_type, &low, + &high, bias, stride, byte_stride_p); + } + else + range_type = create_range_type (NULL, orig_base_type, &low, &high, bias); if (high_bound_is_count) TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1; @@ -18004,7 +18215,7 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu) TYPE_NAME (range_type) = name; attr = dwarf2_attr (die, DW_AT_byte_size, cu); - if (attr) + if (attr != nullptr) TYPE_LENGTH (range_type) = DW_UNSND (attr); maybe_set_alignment (cu, die, range_type); @@ -18027,7 +18238,7 @@ read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu) TYPE_NAME (type) = dwarf2_name (die, cu); /* In Ada, an unspecified type is typically used when the description - of the type is defered to a different unit. When encountering + of the type is deferred to a different unit. When encountering such a type, we treat it as a stub, and try to resolve it later on, when needed. */ if (cu->language == language_ada) @@ -18533,7 +18744,7 @@ load_partial_dies (const struct die_reader_specs *reader, || pdi.tag == DW_TAG_subrange_type)) { if (building_psymtab && pdi.name != NULL) - add_psymbol_to_list (pdi.name, strlen (pdi.name), false, + add_psymbol_to_list (pdi.name, false, VAR_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::STATIC, 0, cu->language, objfile); @@ -18567,7 +18778,7 @@ load_partial_dies (const struct die_reader_specs *reader, if (pdi.name == NULL) complaint (_("malformed enumerator DIE ignored")); else if (building_psymtab) - add_psymbol_to_list (pdi.name, strlen (pdi.name), false, + add_psymbol_to_list (pdi.name, false, VAR_DOMAIN, LOC_CONST, -1, cu->language == language_cplus ? psymbol_placement::GLOBAL @@ -18640,10 +18851,10 @@ load_partial_dies (const struct die_reader_specs *reader, inside functions to find template arguments (if the name of the function does not already contain the template arguments). - For Ada, we need to scan the children of subprograms and lexical - blocks as well because Ada allows the definition of nested - entities that could be interesting for the debugger, such as - nested subprograms for instance. */ + For Ada and Fortran, we need to scan the children of subprograms + and lexical blocks as well because these languages allow the + definition of nested entities that could be interesting for the + debugger, such as nested subprograms for instance. */ if (last_die->has_children && (load_all || last_die->tag == DW_TAG_namespace @@ -18658,7 +18869,8 @@ load_partial_dies (const struct die_reader_specs *reader, || last_die->tag == DW_TAG_interface_type || last_die->tag == DW_TAG_structure_type || last_die->tag == DW_TAG_union_type)) - || (cu->language == language_ada + || ((cu->language == language_ada + || cu->language == language_fortran) && (last_die->tag == DW_TAG_subprogram || last_die->tag == DW_TAG_lexical_block)))) { @@ -19759,11 +19971,11 @@ read_indirect_string_from_dwz (struct objfile *objfile, struct dwz_file *dwz, if (dwz->str.buffer == NULL) error (_("DW_FORM_GNU_strp_alt used without .debug_str " "section [in module %s]"), - bfd_get_filename (dwz->dwz_bfd)); + bfd_get_filename (dwz->dwz_bfd.get ())); if (str_offset >= dwz->str.size) error (_("DW_FORM_GNU_strp_alt pointing outside of " ".debug_str section [in module %s]"), - bfd_get_filename (dwz->dwz_bfd)); + bfd_get_filename (dwz->dwz_bfd.get ())); gdb_assert (HOST_CHAR_BIT == 8); if (dwz->str.buffer[str_offset] == '\0') return NULL; @@ -20168,6 +20380,10 @@ dwarf2_string_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *c if (attr->form == DW_FORM_strp || attr->form == DW_FORM_line_strp || attr->form == DW_FORM_string || attr->form == DW_FORM_strx + || attr->form == DW_FORM_strx1 + || attr->form == DW_FORM_strx2 + || attr->form == DW_FORM_strx3 + || attr->form == DW_FORM_strx4 || attr->form == DW_FORM_GNU_str_index || attr->form == DW_FORM_GNU_strp_alt) str = DW_STRING (attr); @@ -20182,7 +20398,7 @@ dwarf2_string_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *c } /* Return the dwo name or NULL if not present. If present, it is in either - DW_AT_GNU_dwo_name or DW_AT_dwo_name atrribute. */ + DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute. */ static const char * dwarf2_dwo_name (struct die_info *die, struct dwarf2_cu *cu) { @@ -20253,10 +20469,16 @@ void line_header::add_include_dir (const char *include_dir) { if (dwarf_line_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "Adding dir %zu: %s\n", - include_dirs.size () + 1, include_dir); - - include_dirs.push_back (include_dir); + { + size_t new_size; + if (version >= 5) + new_size = m_include_dirs.size (); + else + new_size = m_include_dirs.size () + 1; + fprintf_unfiltered (gdb_stdlog, "Adding dir %zu: %s\n", + new_size, include_dir); + } + m_include_dirs.push_back (include_dir); } void @@ -20266,10 +20488,16 @@ line_header::add_file_name (const char *name, unsigned int length) { if (dwarf_line_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "Adding file %u: %s\n", - (unsigned) file_names.size () + 1, name); - - file_names.emplace_back (name, d_index, mod_time, length); + { + size_t new_size; + if (version >= 5) + new_size = file_names_size (); + else + new_size = file_names_size () + 1; + fprintf_unfiltered (gdb_stdlog, "Adding file %zu: %s\n", + new_size, name); + } + m_file_names.emplace_back (name, d_index, mod_time, length); } /* A convenience function to find the proper .debug_line section for a CU. */ @@ -20383,6 +20611,11 @@ read_formatted_entries (struct dwarf2_per_objfile *dwarf2_per_objfile, buf += 8; break; + case DW_FORM_data16: + /* This is used for MD5, but file_entry does not record MD5s. */ + buf += 16; + break; + case DW_FORM_udata: uint.emplace (read_unsigned_leb128 (abfd, buf, &bytes_read)); buf += bytes_read; @@ -20483,12 +20716,15 @@ dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu) read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header, &bytes_read, &offset_size); line_ptr += bytes_read; + + const gdb_byte *start_here = line_ptr; + if (line_ptr + lh->total_length > (section->buffer + section->size)) { dwarf2_statement_list_fits_in_line_number_section_complaint (); return 0; } - lh->statement_program_end = line_ptr + lh->total_length; + lh->statement_program_end = start_here + lh->total_length; lh->version = read_2_bytes (abfd, line_ptr); line_ptr += 2; if (lh->version > 5) @@ -20518,6 +20754,7 @@ dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu) } lh->header_length = read_offset_1 (abfd, line_ptr, offset_size); line_ptr += offset_size; + lh->statement_program_start = line_ptr + lh->header_length; lh->minimum_instruction_length = read_1_byte (abfd, line_ptr); line_ptr += 1; if (lh->version >= 4) @@ -20602,7 +20839,6 @@ dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu) } line_ptr += bytes_read; } - lh->statement_program_start = line_ptr; if (line_ptr > (section->buffer + section->size)) complaint (_("line number info header doesn't " @@ -20612,19 +20848,17 @@ dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu) } /* Subroutine of dwarf_decode_lines to simplify it. - Return the file name of the psymtab for included file FILE_INDEX - in line header LH of PST. + Return the file name of the psymtab for the given file_entry. COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown. If space for the result is malloc'd, *NAME_HOLDER will be set. Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */ static const char * -psymtab_include_file_name (const struct line_header *lh, int file_index, +psymtab_include_file_name (const struct line_header *lh, const file_entry &fe, const struct partial_symtab *pst, const char *comp_dir, gdb::unique_xmalloc_ptr *name_holder) { - const file_entry &fe = lh->file_names[file_index]; const char *include_name = fe.name; const char *include_name_to_compare = include_name; const char *pst_filename; @@ -20799,8 +21033,8 @@ private: and initialized according to the DWARF spec. */ unsigned char m_op_index = 0; - /* The line table index (1-based) of the current file. */ - file_name_index m_file = (file_name_index) 1; + /* The line table index of the current file. */ + file_name_index m_file = 1; unsigned int m_line = 1; /* These are initialized in the constructor. */ @@ -20992,7 +21226,7 @@ lnp_state_machine::record_line (bool end_sequence) fprintf_unfiltered (gdb_stdlog, "Processing actual line %u: file %u," " address %s, is_stmt %u, discrim %u\n", - m_line, to_underlying (m_file), + m_line, m_file, paddress (m_gdbarch, m_address), m_is_stmt, m_discriminator); } @@ -21331,17 +21565,15 @@ dwarf_decode_lines (struct line_header *lh, const char *comp_dir, if (decode_for_pst_p) { - int file_index; - /* Now that we're done scanning the Line Header Program, we can create the psymtab of each included file. */ - for (file_index = 0; file_index < lh->file_names.size (); file_index++) - if (lh->file_names[file_index].included_p == 1) + for (auto &file_entry : lh->file_names ()) + if (file_entry.included_p == 1) { gdb::unique_xmalloc_ptr name_holder; const char *include_name = - psymtab_include_file_name (lh, file_index, pst, comp_dir, - &name_holder); + psymtab_include_file_name (lh, file_entry, pst, + comp_dir, &name_holder); if (include_name != NULL) dwarf2_create_include_psymtab (include_name, pst, objfile); } @@ -21353,14 +21585,10 @@ dwarf_decode_lines (struct line_header *lh, const char *comp_dir, line numbers). */ buildsym_compunit *builder = cu->get_builder (); struct compunit_symtab *cust = builder->get_compunit_symtab (); - int i; - for (i = 0; i < lh->file_names.size (); i++) + for (auto &fe : lh->file_names ()) { - file_entry &fe = lh->file_names[i]; - dwarf2_start_subfile (cu, fe.name, fe.include_dir (lh)); - if (builder->get_current_subfile ()->symtab == NULL) { builder->get_current_subfile ()->symtab @@ -21484,15 +21712,20 @@ var_decode_location (struct attribute *attr, struct symbol *sym, unsigned int dummy; if (DW_BLOCK (attr)->data[0] == DW_OP_addr) - SYMBOL_VALUE_ADDRESS (sym) = - read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy); + SET_SYMBOL_VALUE_ADDRESS (sym, + read_address (objfile->obfd, + DW_BLOCK (attr)->data + 1, + cu, &dummy)); else - SYMBOL_VALUE_ADDRESS (sym) = - read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy); + SET_SYMBOL_VALUE_ADDRESS + (sym, read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, + &dummy)); SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC; fixup_symbol_section (sym, objfile); - SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, - SYMBOL_SECTION (sym)); + SET_SYMBOL_VALUE_ADDRESS (sym, + SYMBOL_VALUE_ADDRESS (sym) + + ANOFFSET (objfile->section_offsets, + SYMBOL_SECTION (sym))); return; } @@ -21549,15 +21782,15 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu, OBJSTAT (objfile, n_syms++); /* Cache this symbol's name and the name's demangled form (if any). */ - SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack); + sym->set_language (cu->language, &objfile->objfile_obstack); linkagename = dwarf2_physname (name, die, cu); - SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile); + SYMBOL_SET_NAMES (sym, linkagename, false, objfile); /* Fortran does not have mangling standard and the mangling does differ between gfortran, iFort etc. */ if (cu->language == language_fortran - && symbol_get_demangled_name (&(sym->ginfo)) == NULL) - symbol_set_demangled_name (&(sym->ginfo), + && symbol_get_demangled_name (sym) == NULL) + symbol_set_demangled_name (sym, dwarf2_full_name (name, die, cu), NULL); @@ -21572,7 +21805,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu, attr = dwarf2_attr (die, inlined_func ? DW_AT_call_line : DW_AT_decl_line, cu); - if (attr) + if (attr != nullptr) { SYMBOL_LINE (sym) = DW_UNSND (attr); } @@ -21580,7 +21813,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu, attr = dwarf2_attr (die, inlined_func ? DW_AT_call_file : DW_AT_decl_file, cu); - if (attr) + if (attr != nullptr) { file_name_index file_index = (file_name_index) DW_UNSND (attr); struct file_entry *fe; @@ -21600,13 +21833,13 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu, { case DW_TAG_label: attr = dwarf2_attr (die, DW_AT_low_pc, cu); - if (attr) + if (attr != nullptr) { CORE_ADDR addr; addr = attr_value_as_address (attr); addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + baseaddr); - SYMBOL_VALUE_ADDRESS (sym) = addr; + SET_SYMBOL_VALUE_ADDRESS (sym, addr); } SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr; SYMBOL_DOMAIN (sym) = LABEL_DOMAIN; @@ -21619,14 +21852,15 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu, SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK; attr2 = dwarf2_attr (die, DW_AT_external, cu); if ((attr2 && (DW_UNSND (attr2) != 0)) - || cu->language == language_ada) + || cu->language == language_ada + || cu->language == language_fortran) { /* Subprograms marked external are stored as a global symbol. - Ada subprograms, whether marked external or not, are always - stored as a global symbol, because we want to be able to - access them globally. For instance, we want to be able - to break on a nested subprogram without having to - specify the context. */ + Ada and Fortran subprograms, whether marked external or + not, are always stored as a global symbol, because we want + to be able to access them globally. For instance, we want + to be able to break on a nested subprogram without having + to specify the context. */ list_to_add = cu->get_builder ()->get_global_symbols (); } else @@ -21663,7 +21897,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu, gdb_assert (die_is_declaration (die, cu)); gdb_assert (attr); } - if (attr) + if (attr != nullptr) { dwarf2_const_value (attr, sym, cu); attr2 = dwarf2_attr (die, DW_AT_external, cu); @@ -21677,7 +21911,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu, break; } attr = dwarf2_attr (die, DW_AT_location, cu); - if (attr) + if (attr != nullptr) { var_decode_location (attr, sym, cu); attr2 = dwarf2_attr (die, DW_AT_external, cu); @@ -21699,19 +21933,21 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu, } else if (attr2 && (DW_UNSND (attr2) != 0)) { - /* Workaround gfortran PR debug/40040 - it uses - DW_AT_location for variables in -fPIC libraries which may - get overriden by other libraries/executable and get - a different address. Resolve it by the minimal symbol - which may come from inferior's executable using copy - relocation. Make this workaround only for gfortran as for - other compilers GDB cannot guess the minimal symbol - Fortran mangling kind. */ - if (cu->language == language_fortran && die->parent - && die->parent->tag == DW_TAG_module - && cu->producer - && startswith (cu->producer, "GNU Fortran")) - SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED; + if (SYMBOL_CLASS (sym) == LOC_STATIC + && (objfile->flags & OBJF_MAINLINE) == 0 + && dwarf2_per_objfile->can_copy) + { + /* A global static variable might be subject to + copy relocation. We first check for a local + minsym, though, because maybe the symbol was + marked hidden, in which case this would not + apply. */ + bound_minimal_symbol found + = (lookup_minimal_symbol_linkage + (sym->linkage_name (), objfile)); + if (found.minsym != nullptr) + sym->maybe_copied = 1; + } /* A variable with DW_AT_external is never static, but it may be block-scoped. */ @@ -21778,12 +22014,12 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu, if (curr != nullptr && curr->name != nullptr) SYMBOL_IS_ARGUMENT (sym) = 1; attr = dwarf2_attr (die, DW_AT_location, cu); - if (attr) + if (attr != nullptr) { var_decode_location (attr, sym, cu); } attr = dwarf2_attr (die, DW_AT_const_value, cu); - if (attr) + if (attr != nullptr) { dwarf2_const_value (attr, sym, cu); } @@ -21837,7 +22073,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu, with this objfile, so we don't need to duplicate it for the type. */ if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0) - TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym); + TYPE_NAME (SYMBOL_TYPE (sym)) = sym->search_name (); } } } @@ -21855,7 +22091,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu, break; case DW_TAG_enumerator: attr = dwarf2_attr (die, DW_AT_const_value, cu); - if (attr) + if (attr != nullptr) { dwarf2_const_value (attr, sym, cu); } @@ -22070,7 +22306,7 @@ dwarf2_const_value (const struct attribute *attr, struct symbol *sym, struct dwarf2_locexpr_baton *baton; dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym), - SYMBOL_PRINT_NAME (sym), + sym->print_name (), &objfile->objfile_obstack, cu, &value, &bytes, &baton); @@ -22621,6 +22857,16 @@ determine_prefix (struct die_info *die, struct dwarf2_cu *cu) return name; } return ""; + case DW_TAG_subprogram: + /* Nested subroutines in Fortran get a prefix with the name + of the parent's subroutine. */ + if (cu->language == language_fortran) + { + if ((die->tag == DW_TAG_subprogram) + && (dwarf2_name (parent, cu) != NULL)) + return dwarf2_name (parent, cu); + } + return determine_prefix (parent, cu); case DW_TAG_enumeration_type: parent_type = read_type_die (parent, cu); if (TYPE_DECLARED_CLASS (parent_type)) @@ -23062,7 +23308,7 @@ dump_die_shallow (struct ui_file *f, int indent, struct die_info *die) case DW_FORM_indirect: /* The reader will have reduced the indirect form to the "base form" so this form should not occur. */ - fprintf_unfiltered (f, + fprintf_unfiltered (f, "unexpected attribute form: DW_FORM_indirect"); break; case DW_FORM_implicit_const: @@ -23628,9 +23874,7 @@ follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type, if (dwarf2_per_objfile->index_table != NULL && dwarf2_per_objfile->index_table->version <= 7) { - VEC_safe_push (dwarf2_per_cu_ptr, - (*ref_cu)->per_cu->imported_symtabs, - sig_cu->per_cu); + (*ref_cu)->per_cu->imported_symtabs_push (sig_cu->per_cu); } *ref_cu = sig_cu; @@ -24149,17 +24393,17 @@ file_file_name (int file, struct line_header *lh) { /* Is the file number a valid index into the line header's file name table? Remember that file numbers start with one, not zero. */ - if (1 <= file && file <= lh->file_names.size ()) + if (lh->is_valid_file_index (file)) { - const file_entry &fe = lh->file_names[file - 1]; + const file_entry *fe = lh->file_name_at (file); - if (!IS_ABSOLUTE_PATH (fe.name)) + if (!IS_ABSOLUTE_PATH (fe->name)) { - const char *dir = fe.include_dir (lh); + const char *dir = fe->include_dir (lh); if (dir != NULL) - return concat (dir, SLASH_STRING, fe.name, (char *) NULL); + return concat (dir, SLASH_STRING, fe->name, (char *) NULL); } - return xstrdup (fe.name); + return xstrdup (fe->name); } else { @@ -24187,7 +24431,7 @@ file_full_name (int file, struct line_header *lh, const char *comp_dir) { /* Is the file number a valid index into the line header's file name table? Remember that file numbers start with one, not zero. */ - if (1 <= file && file <= lh->file_names.size ()) + if (lh->is_valid_file_index (file)) { char *relative = file_file_name (file, lh); @@ -25163,7 +25407,7 @@ cu_debug_loc_section (struct dwarf2_cu *cu) if (cu->dwo_unit) { struct dwo_sections *sections = &cu->dwo_unit->dwo_file->sections; - + return cu->header.version >= 5 ? §ions->loclists : §ions->loc; } return (cu->header.version >= 5 ? &dwarf2_per_objfile->loclists @@ -25244,7 +25488,7 @@ dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym, else { dwarf2_invalid_attrib_class_complaint ("location description", - SYMBOL_NATURAL_NAME (sym)); + sym->natural_name ()); baton->size = 0; } @@ -25459,7 +25703,7 @@ prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die, /* Set the language we're debugging. */ attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu); - if (attr) + if (attr != nullptr) set_cu_language (DW_UNSND (attr), cu); else { @@ -25589,7 +25833,7 @@ per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs) table if necessary. For convenience, return TYPE. The DIEs reading must have careful ordering to: - * Not cause infite loops trying to read in DIEs as a prerequisite for + * Not cause infinite loops trying to read in DIEs as a prerequisite for reading current DIE. * Not trying to dereference contents of still incompletely read in types while reading in other DIEs.