- if (warn_if_readin && per_objfile->symtab_set_p (per_cu))
- warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
- paddress (objfile->arch (), pc));
-
- compunit_symtab *result = (recursively_find_pc_sect_compunit_symtab
- (dw2_instantiate_symtab (per_cu, per_objfile,
- false),
- pc));
- gdb_assert (result != nullptr);
- return result;
-}
-
-struct compunit_symtab *
-cooked_index_functions::find_compunit_symtab_by_address
- (struct objfile *objfile, CORE_ADDR address)
-{
- if (objfile->sect_index_data == -1)
- return nullptr;
-
- dwarf2_per_objfile *per_objfile = get_dwarf2_per_objfile (objfile);
- if (per_objfile->per_bfd->cooked_index_table == nullptr)
- return nullptr;
-
- CORE_ADDR baseaddr = objfile->data_section_offset ();
- dwarf2_per_cu_data *per_cu
- = per_objfile->per_bfd->cooked_index_table->lookup (address - baseaddr);
- if (per_cu == nullptr)
- return nullptr;
-
- return dw2_instantiate_symtab (per_cu, per_objfile, false);
-}
-
-void
-cooked_index_functions::expand_matching_symbols
- (struct objfile *objfile,
- const lookup_name_info &lookup_name,
- domain_enum domain,
- int global,
- symbol_compare_ftype *ordered_compare)
-{
- dwarf2_per_objfile *per_objfile = get_dwarf2_per_objfile (objfile);
- if (per_objfile->per_bfd->cooked_index_table == nullptr)
- return;
- const block_search_flags search_flags = (global
- ? SEARCH_GLOBAL_BLOCK
- : SEARCH_STATIC_BLOCK);
- const language_defn *lang = language_def (language_ada);
- symbol_name_matcher_ftype *name_match
- = lang->get_symbol_name_matcher (lookup_name);
-
- for (const cooked_index_entry *entry
- : per_objfile->per_bfd->cooked_index_table->all_entries ())
- {
- if (entry->parent_entry != nullptr)
- continue;
-
- if (!entry->matches (search_flags)
- || !entry->matches (domain))
- continue;
-
- if (name_match (entry->canonical, lookup_name, nullptr))
- dw2_instantiate_symtab (entry->per_cu, per_objfile, false);
- }
-}
-
-bool
-cooked_index_functions::expand_symtabs_matching
- (struct objfile *objfile,
- gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
- const lookup_name_info *lookup_name,
- gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
- gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
- block_search_flags search_flags,
- domain_enum domain,
- enum search_domain kind)
-{
- dwarf2_per_objfile *per_objfile = get_dwarf2_per_objfile (objfile);
- if (per_objfile->per_bfd->cooked_index_table == nullptr)
- return true;
-
- dw_expand_symtabs_matching_file_matcher (per_objfile, file_matcher);
-
- /* This invariant is documented in quick-functions.h. */
- gdb_assert (lookup_name != nullptr || symbol_matcher == nullptr);
- if (lookup_name == nullptr)
- {
- for (dwarf2_per_cu_data *per_cu
- : all_comp_units_range (per_objfile->per_bfd))
- {
- QUIT;
-
- if (!dw2_expand_symtabs_matching_one (per_cu, per_objfile,
- file_matcher,
- expansion_notify))
- return false;
- }
- return true;
- }
-
- lookup_name_info lookup_name_without_params
- = lookup_name->make_ignore_params ();
- bool completing = lookup_name->completion_mode ();
-
- /* Unique styles of language splitting. */
- static const enum language unique_styles[] =
- {
- /* No splitting is also a style. */
- language_c,
- /* This includes Rust. */
- language_cplus,
- /* This includes Go. */
- language_d,
- language_ada
- };
-
- for (enum language lang : unique_styles)
- {
- std::vector<gdb::string_view> name_vec
- = lookup_name_without_params.split_name (lang);
-
- for (const cooked_index_entry *entry
- : per_objfile->per_bfd->cooked_index_table->find (name_vec.back (),
- completing))
- {
- /* No need to consider symbols from expanded CUs. */
- if (per_objfile->symtab_set_p (entry->per_cu))
- continue;
-
- /* If file-matching was done, we don't need to consider
- symbols from unmarked CUs. */
- if (file_matcher != nullptr && !entry->per_cu->v.quick->mark)
- continue;
-
- /* See if the symbol matches the type filter. */
- if (!entry->matches (search_flags)
- || !entry->matches (domain)
- || !entry->matches (kind))
- continue;
-
- /* We've found the base name of the symbol; now walk its
- parentage chain, ensuring that each component
- matches. */
- bool found = true;
-
- const cooked_index_entry *parent = entry->parent_entry;
- for (int i = name_vec.size () - 1; i > 0; --i)
- {
- /* If we ran out of entries, or if this segment doesn't
- match, this did not match. */
- if (parent == nullptr
- || strncmp (parent->name, name_vec[i - 1].data (),
- name_vec[i - 1].length ()) != 0)
- {
- found = false;
- break;
- }
-
- parent = parent->parent_entry;
- }
-
- if (!found)
- continue;
-
- /* Might have been looking for "a::b" and found
- "x::a::b". */
- if (symbol_matcher == nullptr)
- {
- symbol_name_match_type match_type
- = lookup_name_without_params.match_type ();
- if ((match_type == symbol_name_match_type::FULL
- || (lang != language_ada
- && match_type == symbol_name_match_type::EXPRESSION))
- && parent != nullptr)
- continue;
- }
- else
- {
- auto_obstack temp_storage;
- const char *full_name = entry->full_name (&temp_storage);
- if (!symbol_matcher (full_name))
- continue;
- }
-
- if (!dw2_expand_symtabs_matching_one (entry->per_cu, per_objfile,
- file_matcher,
- expansion_notify))
- return false;
- }
- }
-
- return true;
-}
-
-/* Return a new cooked_index_functions object. */
-
-static quick_symbol_functions_up
-make_cooked_index_funcs ()
-{
- return quick_symbol_functions_up (new cooked_index_functions);
-}
-
-\f
-
-/* Returns nonzero if TAG represents a type that we might generate a partial
- symbol for. */
-
-static int
-is_type_tag_for_partial (int tag, enum language lang)
-{
- switch (tag)
- {
-#if 0
- /* Some types that would be reasonable to generate partial symbols for,
- that we don't at present. Note that normally this does not
- matter, mainly because C compilers don't give names to these
- types, but instead emit DW_TAG_typedef. */
- case DW_TAG_file_type:
- case DW_TAG_ptr_to_member_type:
- case DW_TAG_set_type:
- case DW_TAG_string_type:
- case DW_TAG_subroutine_type:
-#endif
-
- /* GNAT may emit an array with a name, but no typedef, so we
- need to make a symbol in this case. */
- case DW_TAG_array_type:
- return lang == language_ada;
-
- case DW_TAG_base_type:
- case DW_TAG_class_type:
- case DW_TAG_interface_type:
- case DW_TAG_enumeration_type:
- case DW_TAG_structure_type:
- case DW_TAG_subrange_type:
- case DW_TAG_generic_subrange:
- case DW_TAG_typedef:
- case DW_TAG_union_type:
- return 1;
- default:
- return 0;
- }
-}
-
-/* Load all DIEs that are interesting for partial symbols into memory. */
-
-static struct partial_die_info *
-load_partial_dies (const struct die_reader_specs *reader,
- const gdb_byte *info_ptr, int building_psymtab)
-{
- struct dwarf2_cu *cu = reader->cu;
- struct objfile *objfile = cu->per_objfile->objfile;
- struct partial_die_info *parent_die, *last_die, *first_die = NULL;
- unsigned int bytes_read;
- unsigned int load_all = 0;
- int nesting_level = 1;
-
- parent_die = NULL;
- last_die = NULL;
-
- gdb_assert (cu->per_cu != NULL);
- if (cu->load_all_dies)
- load_all = 1;
-
- cu->partial_dies
- = htab_create_alloc_ex (cu->header.length / 12,
- partial_die_hash,
- partial_die_eq,
- NULL,
- &cu->comp_unit_obstack,
- hashtab_obstack_allocate,
- dummy_obstack_deallocate);
-
- while (1)
- {
- const abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr,
- &bytes_read);
-
- /* A NULL abbrev means the end of a series of children. */
- if (abbrev == NULL)
- {
- if (--nesting_level == 0)
- return first_die;
-
- info_ptr += bytes_read;
- last_die = parent_die;
- parent_die = parent_die->die_parent;
- continue;
- }
-
- /* Check for template arguments. We never save these; if
- they're seen, we just mark the parent, and go on our way. */
- if (parent_die != NULL
- && cu->per_cu->lang == language_cplus
- && (abbrev->tag == DW_TAG_template_type_param
- || abbrev->tag == DW_TAG_template_value_param))
- {
- parent_die->has_template_arguments = 1;
-
- if (!load_all)
- {
- /* We don't need a partial DIE for the template argument. */
- info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
- continue;
- }
- }
-
- /* We only recurse into c++ subprograms looking for template arguments.
- Skip their other children. */
- if (!load_all
- && cu->per_cu->lang == language_cplus
- && parent_die != NULL
- && parent_die->tag == DW_TAG_subprogram
- && abbrev->tag != DW_TAG_inlined_subroutine)
- {
- info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
- continue;
- }
-
- /* Check whether this DIE is interesting enough to save. Normally
- we would not be interested in members here, but there may be
- later variables referencing them via DW_AT_specification (for
- static members). */
- if (!load_all
- && !is_type_tag_for_partial (abbrev->tag, cu->per_cu->lang)
- && abbrev->tag != DW_TAG_constant
- && abbrev->tag != DW_TAG_enumerator
- && abbrev->tag != DW_TAG_subprogram
- && abbrev->tag != DW_TAG_inlined_subroutine
- && abbrev->tag != DW_TAG_lexical_block
- && abbrev->tag != DW_TAG_variable
- && abbrev->tag != DW_TAG_namespace
- && abbrev->tag != DW_TAG_module
- && abbrev->tag != DW_TAG_member
- && abbrev->tag != DW_TAG_imported_unit
- && abbrev->tag != DW_TAG_imported_declaration)
- {
- /* Otherwise we skip to the next sibling, if any. */
- info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
- continue;
- }
-
- struct partial_die_info pdi ((sect_offset) (info_ptr - reader->buffer),
- abbrev);
-
- info_ptr = pdi.read (reader, *abbrev, info_ptr + bytes_read);
-
- /* This two-pass algorithm for processing partial symbols has a
- high cost in cache pressure. Thus, handle some simple cases
- here which cover the majority of C partial symbols. DIEs
- which neither have specification tags in them, nor could have
- specification tags elsewhere pointing at them, can simply be
- processed and discarded.
-
- This segment is also optional; scan_partial_symbols and
- add_partial_symbol will handle these DIEs if we chain
- them in normally. When compilers which do not emit large
- quantities of duplicate debug information are more common,
- this code can probably be removed. */
-
- /* Any complete simple types at the top level (pretty much all
- of them, for a language without namespaces), can be processed
- directly. */
- if (parent_die == NULL
- && pdi.has_specification == 0
- && pdi.is_declaration == 0
- && ((pdi.tag == DW_TAG_typedef && !pdi.has_children)
- || pdi.tag == DW_TAG_base_type
- || pdi.tag == DW_TAG_array_type
- || pdi.tag == DW_TAG_generic_subrange
- || pdi.tag == DW_TAG_subrange_type))
- {
- if (building_psymtab && pdi.raw_name != NULL)
- add_partial_symbol (&pdi, cu);
-
- info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
- continue;
- }
-
- /* The exception for DW_TAG_typedef with has_children above is
- a workaround of GCC PR debug/47510. In the case of this complaint
- type_name_or_error will error on such types later.
-
- GDB skipped children of DW_TAG_typedef by the shortcut above and then
- it could not find the child DIEs referenced later, this is checked
- above. In correct DWARF DW_TAG_typedef should have no children. */
-
- if (pdi.tag == DW_TAG_typedef && pdi.has_children)
- complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
- "- DIE at %s [in module %s]"),
- sect_offset_str (pdi.sect_off), objfile_name (objfile));
-
- /* If we're at the second level, and we're an enumerator, and
- our parent has no specification (meaning possibly lives in a
- namespace elsewhere), then we can add the partial symbol now
- instead of queueing it. */
- if (pdi.tag == DW_TAG_enumerator
- && parent_die != NULL
- && parent_die->die_parent == NULL
- && parent_die->tag == DW_TAG_enumeration_type
- && parent_die->has_specification == 0)
- {
- if (pdi.raw_name == NULL)
- complaint (_("malformed enumerator DIE ignored"));
- else if (building_psymtab)
- add_partial_symbol (&pdi, cu);
-
- info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
- continue;
- }
-
- struct partial_die_info *part_die
- = new (&cu->comp_unit_obstack) partial_die_info (pdi);
-
- /* We'll save this DIE so link it in. */
- part_die->die_parent = parent_die;
- part_die->die_sibling = NULL;
- part_die->die_child = NULL;
-
- if (last_die && last_die == parent_die)
- last_die->die_child = part_die;
- else if (last_die)
- last_die->die_sibling = part_die;
-
- last_die = part_die;
-
- if (first_die == NULL)
- first_die = part_die;
-
- /* Maybe add the DIE to the hash table. Not all DIEs that we
- find interesting need to be in the hash table, because we
- also have the parent/sibling/child chains; only those that we
- might refer to by offset later during partial symbol reading.
-
- For now this means things that might have be the target of a
- DW_AT_specification, DW_AT_abstract_origin, or
- DW_AT_extension. DW_AT_extension will refer only to
- namespaces; DW_AT_abstract_origin refers to functions (and
- many things under the function DIE, but we do not recurse
- into function DIEs during partial symbol reading) and
- possibly variables as well; DW_AT_specification refers to
- declarations. Declarations ought to have the DW_AT_declaration
- flag. It happens that GCC forgets to put it in sometimes, but
- only for functions, not for types.
-
- Adding more things than necessary to the hash table is harmless
- except for the performance cost. Adding too few will result in
- wasted time in find_partial_die, when we reread the compilation
- unit with load_all_dies set. */
-
- if (load_all
- || abbrev->tag == DW_TAG_constant
- || abbrev->tag == DW_TAG_subprogram
- || abbrev->tag == DW_TAG_variable
- || abbrev->tag == DW_TAG_namespace
- || part_die->is_declaration)
- {
- void **slot;
-
- slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
- to_underlying (part_die->sect_off),
- INSERT);
- *slot = part_die;
- }
-
- /* For some DIEs we want to follow their children (if any). For C
- we have no reason to follow the children of structures; for other
- languages we have to, so that we can get at method physnames
- to infer fully qualified class names, for DW_AT_specification,
- and for C++ template arguments. For C++, we also look one level
- inside functions to find template arguments (if the name of the
- function does not already contain the template arguments).
-
- 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
- || last_die->tag == DW_TAG_module
- || last_die->tag == DW_TAG_enumeration_type
- || (cu->per_cu->lang == language_cplus
- && last_die->tag == DW_TAG_subprogram
- && (last_die->raw_name == NULL
- || strchr (last_die->raw_name, '<') == NULL))
- || (cu->per_cu->lang != language_c
- && (last_die->tag == DW_TAG_class_type
- || last_die->tag == DW_TAG_interface_type
- || last_die->tag == DW_TAG_structure_type
- || last_die->tag == DW_TAG_union_type))
- || ((cu->per_cu->lang == language_ada
- || cu->per_cu->lang == language_fortran)
- && (last_die->tag == DW_TAG_subprogram
- || last_die->tag == DW_TAG_lexical_block))))
- {
- nesting_level++;
- parent_die = last_die;
- continue;
- }
-
- /* Otherwise we skip to the next sibling, if any. */
- info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
-
- /* Back to the top, do it again. */
- }
-}
-
-partial_die_info::partial_die_info (sect_offset sect_off_,
- const struct abbrev_info *abbrev)
- : partial_die_info (sect_off_, abbrev->tag, abbrev->has_children)
-{
-}
-
-/* See class definition. */
-
-const char *
-partial_die_info::name (dwarf2_cu *cu)
-{
- if (!canonical_name && raw_name != nullptr)
- {
- struct objfile *objfile = cu->per_objfile->objfile;
- raw_name = dwarf2_canonicalize_name (raw_name, cu, objfile);
- canonical_name = 1;
- }
-
- return raw_name;
-}
-
-/* Read a minimal amount of information into the minimal die structure.
- INFO_PTR should point just after the initial uleb128 of a DIE. */
-
-const gdb_byte *
-partial_die_info::read (const struct die_reader_specs *reader,
- const struct abbrev_info &abbrev, const gdb_byte *info_ptr)
-{
- struct dwarf2_cu *cu = reader->cu;
- dwarf2_per_objfile *per_objfile = cu->per_objfile;
- unsigned int i;
- int has_low_pc_attr = 0;
- int has_high_pc_attr = 0;
- int high_pc_relative = 0;
-
- for (i = 0; i < abbrev.num_attrs; ++i)
- {
- attribute attr;
- info_ptr = read_attribute (reader, &attr, &abbrev.attrs[i], info_ptr);
- /* String and address offsets that need to do the reprocessing have
- already been read at this point, so there is no need to wait until
- the loop terminates to do the reprocessing. */
- if (attr.requires_reprocessing_p ())
- read_attribute_reprocess (reader, &attr, tag);
- /* Store the data if it is of an attribute we want to keep in a
- partial symbol table. */
- switch (attr.name)
- {
- case DW_AT_name:
- switch (tag)
- {
- case DW_TAG_compile_unit:
- case DW_TAG_partial_unit:
- case DW_TAG_type_unit:
- /* Compilation units have a DW_AT_name that is a filename, not
- a source language identifier. */
- case DW_TAG_enumeration_type:
- case DW_TAG_enumerator:
- /* These tags always have simple identifiers already; no need
- to canonicalize them. */
- canonical_name = 1;
- raw_name = attr.as_string ();
- break;
- default:
- canonical_name = 0;
- raw_name = attr.as_string ();
- break;
- }
- break;
- case DW_AT_linkage_name:
- case DW_AT_MIPS_linkage_name:
- /* Note that both forms of linkage name might appear. We
- assume they will be the same, and we only store the last
- one we see. */
- linkage_name = attr.as_string ();
- break;
- case DW_AT_low_pc:
- has_low_pc_attr = 1;
- lowpc = attr.as_address ();
- break;
- case DW_AT_high_pc:
- has_high_pc_attr = 1;
- highpc = attr.as_address ();
- if (cu->header.version >= 4 && attr.form_is_constant ())
- high_pc_relative = 1;
- break;
- case DW_AT_location:
- /* Support the .debug_loc offsets. */
- if (attr.form_is_block ())
- {
- d.locdesc = attr.as_block ();
- }
- else if (attr.form_is_section_offset ())
- {
- dwarf2_complex_location_expr_complaint ();
- }
- else
- {
- dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
- "partial symbol information");
- }
- break;
- case DW_AT_external:
- is_external = attr.as_boolean ();
- break;
- case DW_AT_declaration:
- is_declaration = attr.as_boolean ();
- break;
- case DW_AT_type:
- has_type = 1;
- break;
- case DW_AT_abstract_origin:
- case DW_AT_specification:
- case DW_AT_extension:
- has_specification = 1;
- spec_offset = attr.get_ref_die_offset ();
- spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
- || cu->per_cu->is_dwz);
- break;
- case DW_AT_sibling:
- /* Ignore absolute siblings, they might point outside of
- the current compile unit. */
- if (attr.form == DW_FORM_ref_addr)
- complaint (_("ignoring absolute DW_AT_sibling"));
- else
- {
- const gdb_byte *buffer = reader->buffer;
- sect_offset off = attr.get_ref_die_offset ();
- const gdb_byte *sibling_ptr = buffer + to_underlying (off);
-
- if (sibling_ptr < info_ptr)
- complaint (_("DW_AT_sibling points backwards"));
- else if (sibling_ptr > reader->buffer_end)
- reader->die_section->overflow_complaint ();
- else
- sibling = sibling_ptr;
- }
- break;
- case DW_AT_byte_size:
- has_byte_size = 1;
- break;
- case DW_AT_const_value:
- has_const_value = 1;
- break;
- case DW_AT_calling_convention:
- /* DWARF doesn't provide a way to identify a program's source-level
- entry point. DW_AT_calling_convention attributes are only meant
- to describe functions' calling conventions.
-
- However, because it's a necessary piece of information in
- Fortran, and before DWARF 4 DW_CC_program was the only
- piece of debugging information whose definition refers to
- a 'main program' at all, several compilers marked Fortran
- main programs with DW_CC_program --- even when those
- functions use the standard calling conventions.
-
- Although DWARF now specifies a way to provide this
- information, we support this practice for backward
- compatibility. */
- if (attr.constant_value (0) == DW_CC_program
- && cu->per_cu->lang == language_fortran)
- main_subprogram = 1;
- break;
- case DW_AT_inline:
- {
- LONGEST value = attr.constant_value (-1);
- if (value == DW_INL_inlined
- || value == DW_INL_declared_inlined)
- may_be_inlined = 1;
- }
- break;
-
- case DW_AT_import:
- if (tag == DW_TAG_imported_unit)
- {
- d.sect_off = attr.get_ref_die_offset ();
- is_dwz = (attr.form == DW_FORM_GNU_ref_alt
- || cu->per_cu->is_dwz);
- }
- break;
-
- case DW_AT_main_subprogram:
- main_subprogram = attr.as_boolean ();
- break;
-
- case DW_AT_ranges:
- {
- /* Offset in the .debug_ranges or .debug_rnglist section (depending
- on DWARF version). */
- ranges_offset = attr.as_unsigned ();
-
- /* See dwarf2_cu::gnu_ranges_base's doc for why we might want to add
- this value. */
- if (tag != DW_TAG_compile_unit)
- ranges_offset += cu->gnu_ranges_base;
-
- has_range_info = 1;
- }
- break;
-
- default:
- break;
- }
- }
-
- /* For Ada, if both the name and the linkage name appear, we prefer
- the latter. This lets "catch exception" work better, regardless
- of the order in which the name and linkage name were emitted.
- Really, though, this is just a workaround for the fact that gdb
- doesn't store both the name and the linkage name. */
- if (cu->per_cu->lang == language_ada && linkage_name != nullptr)
- raw_name = linkage_name;
-
- if (high_pc_relative)
- highpc += lowpc;
-
- if (has_low_pc_attr && has_high_pc_attr)
- {
- /* When using the GNU linker, .gnu.linkonce. sections are used to
- eliminate duplicate copies of functions and vtables and such.
- The linker will arbitrarily choose one and discard the others.
- The AT_*_pc values for such functions refer to local labels in
- these sections. If the section from that file was discarded, the
- labels are not in the output, so the relocs get a value of 0.
- If this is a discarded function, mark the pc bounds as invalid,
- so that GDB will ignore it. */
- if (lowpc == 0 && !per_objfile->per_bfd->has_section_at_zero)
- {
- struct objfile *objfile = per_objfile->objfile;
- struct gdbarch *gdbarch = objfile->arch ();
-
- complaint (_("DW_AT_low_pc %s is zero "
- "for DIE at %s [in module %s]"),
- paddress (gdbarch, lowpc),
- sect_offset_str (sect_off),
- objfile_name (objfile));
- }
- /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
- else if (lowpc >= highpc)
- {
- struct objfile *objfile = per_objfile->objfile;
- struct gdbarch *gdbarch = objfile->arch ();
-
- complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
- "for DIE at %s [in module %s]"),
- paddress (gdbarch, lowpc),
- paddress (gdbarch, highpc),
- sect_offset_str (sect_off),
- objfile_name (objfile));
- }
- else
- has_pc_info = 1;
- }
-
- return info_ptr;
-}
-
-/* Find a cached partial DIE at OFFSET in CU. */
-
-struct partial_die_info *
-dwarf2_cu::find_partial_die (sect_offset sect_off)
-{
- struct partial_die_info *lookup_die = NULL;
- struct partial_die_info part_die (sect_off);
-
- lookup_die = ((struct partial_die_info *)
- htab_find_with_hash (partial_dies, &part_die,
- to_underlying (sect_off)));