C-like) lookups to get the first match. */
struct symbol *atcb_sym =
- lookup_symbol_in_language (atcb_name, NULL, SEARCH_STRUCT_DOMAIN,
+ lookup_symbol_in_language (atcb_name, NULL, SEARCH_TYPE_DOMAIN,
language_c, NULL).symbol;
const struct symbol *common_atcb_sym =
- lookup_symbol_in_language (common_atcb_name, NULL, SEARCH_STRUCT_DOMAIN,
+ lookup_symbol_in_language (common_atcb_name, NULL, SEARCH_TYPE_DOMAIN,
language_c, NULL).symbol;
const struct symbol *private_data_sym =
- lookup_symbol_in_language (private_data_name, NULL, SEARCH_STRUCT_DOMAIN,
+ lookup_symbol_in_language (private_data_name, NULL, SEARCH_TYPE_DOMAIN,
language_c, NULL).symbol;
const struct symbol *entry_call_record_sym =
lookup_symbol_in_language (entry_call_record_name, NULL,
- SEARCH_STRUCT_DOMAIN,
+ SEARCH_TYPE_DOMAIN,
language_c, NULL).symbol;
if (atcb_sym == NULL || atcb_sym->type () == NULL)
/* In Ravenscar run-time libs, the ATCB does not have a dynamic
size, so the symbol name differs. */
atcb_sym = lookup_symbol_in_language (atcb_name_fixed, NULL,
- SEARCH_STRUCT_DOMAIN, language_c,
+ SEARCH_TYPE_DOMAIN, language_c,
NULL).symbol;
if (atcb_sym == NULL || atcb_sym->type () == NULL)
but search the whole chain, as there may be several syms
from different files with the same name. */
if (real_sym->aclass () == LOC_TYPEDEF
- && real_sym->domain () == VAR_DOMAIN
+ && real_sym->domain () == TYPE_DOMAIN
&& real_sym->type ()->code () == TYPE_CODE_PTR
&& real_sym->type ()->target_type ()->length () != 0)
{
if (ISFCN (cs->c_type))
{
+ sym->set_domain (FUNCTION_DOMAIN);
sym->set_value_longest
(sym->value_longest () + objfile->text_section_offset ());
sym->set_type
case C_TPDEF:
sym->set_aclass_index (LOC_TYPEDEF);
- sym->set_domain (VAR_DOMAIN);
+ sym->set_domain (TYPE_DOMAIN);
/* If type has no name, give it one. */
if (sym->type ()->name () == 0)
case CTF_K_INTEGER:
case CTF_K_FLOAT:
sym->set_aclass_index (LOC_TYPEDEF);
- sym->set_domain (VAR_DOMAIN);
+ sym->set_domain (TYPE_DOMAIN);
break;
case CTF_K_POINTER:
break;
if ((flags & IS_TYPE_DECLARATION) != 0)
return false;
- if ((kind & SEARCH_VAR_DOMAIN) != 0
- && (tag == DW_TAG_variable
- || tag == DW_TAG_constant
- || tag == DW_TAG_enumerator))
- return true;
-
- if ((kind & SEARCH_STRUCT_DOMAIN) != 0
- && (tag == DW_TAG_structure_type
- || tag == DW_TAG_class_type
- || tag == DW_TAG_union_type
- || tag == DW_TAG_enumeration_type))
- return true;
-
- if ((kind & SEARCH_MODULE_DOMAIN) != 0 && tag == DW_TAG_module)
- return true;
-
- if ((kind & SEARCH_TYPE_DOMAIN) != 0 && tag_is_type (tag))
- return true;
-
- if ((kind & SEARCH_FUNCTION_DOMAIN) != 0
- && (tag == DW_TAG_subprogram
- || tag == DW_TAG_entry_point))
- return true;
-
- return false;
+ return tag_matches_domain (tag, kind, lang);
}
/* See cooked-index.h. */
|| entry->tag == DW_TAG_constant
|| entry->tag == DW_TAG_enumerator)
kind = GDB_INDEX_SYMBOL_KIND_VARIABLE;
- else if (entry->tag == DW_TAG_module
- || entry->tag == DW_TAG_common_block)
- kind = GDB_INDEX_SYMBOL_KIND_OTHER;
- else
+ else if (tag_is_type (entry->tag))
kind = GDB_INDEX_SYMBOL_KIND_TYPE;
+ else
+ kind = GDB_INDEX_SYMBOL_KIND_OTHER;
symtab->add_index_entry (name, (entry->flags & IS_STATIC) != 0,
kind, it->second);
mask = SEARCH_FUNCTION_DOMAIN;
break;
case GDB_INDEX_SYMBOL_KIND_TYPE:
- mask = SEARCH_TYPE_DOMAIN;
+ mask = SEARCH_TYPE_DOMAIN | SEARCH_STRUCT_DOMAIN;
break;
case GDB_INDEX_SYMBOL_KIND_OTHER:
mask = SEARCH_MODULE_DOMAIN;
sym = new (&objfile->objfile_obstack) symbol;
sym->set_language (language_go, &objfile->objfile_obstack);
sym->compute_and_set_names (saved_package_name, false, objfile->per_bfd);
- /* 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(). */
- sym->set_domain (STRUCT_DOMAIN);
+ sym->set_domain (TYPE_DOMAIN);
sym->set_aclass_index (LOC_TYPEDEF);
sym->set_type (type);
/* Default assumptions.
Use the passed type or decode it from the die. */
- sym->set_domain (VAR_DOMAIN);
+ sym->set_domain (UNDEF_DOMAIN);
sym->set_aclass_index (LOC_OPTIMIZED_OUT);
if (type != NULL)
sym->set_type (type);
case DW_TAG_entry_point:
/* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
finish_block. */
+ sym->set_domain (FUNCTION_DOMAIN);
sym->set_aclass_index (LOC_BLOCK);
/* DW_TAG_entry_point provides an additional entry_point to an
existing sub_program. Therefore, we inherit the "external"
case DW_TAG_subprogram:
/* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
finish_block. */
+ sym->set_domain (FUNCTION_DOMAIN);
sym->set_aclass_index (LOC_BLOCK);
attr2 = dwarf2_attr (die, DW_AT_external, cu);
if ((attr2 != nullptr && attr2->as_boolean ())
case DW_TAG_inlined_subroutine:
/* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
finish_block. */
+ sym->set_domain (FUNCTION_DOMAIN);
sym->set_aclass_index (LOC_BLOCK);
sym->set_is_inlined (1);
list_to_add = cu->list_in_scope;
case DW_TAG_constant:
case DW_TAG_variable:
case DW_TAG_member:
+ sym->set_domain (VAR_DOMAIN);
/* Compilation with minimal debug info may result in
variables with missing type entries. Change the
misleading `void' type to something sensible. */
when we do not have enough information to show inlined frames;
pretend it's a local variable in that case so that the user can
still see it. */
+ sym->set_domain (VAR_DOMAIN);
struct context_stack *curr
= cu->get_builder ()->get_current_context_stack ();
if (curr != nullptr && curr->name != nullptr)
sym->set_aclass_index (LOC_STATIC);
sym->set_domain (VAR_DOMAIN);
}
- else
+ else if (cu->lang () == language_c
+ || cu->lang () == language_cplus
+ || cu->lang () == language_objc
+ || cu->lang () == language_opencl
+ || cu->lang () == language_minimal)
{
+ /* These languages have a tag namespace. Note that
+ there's a special hack for C++ in the matching code,
+ so we don't need to enter a separate typedef for the
+ tag. */
sym->set_aclass_index (LOC_TYPEDEF);
sym->set_domain (STRUCT_DOMAIN);
}
+ else
+ {
+ /* Other languages don't have a tag namespace. */
+ sym->set_aclass_index (LOC_TYPEDEF);
+ sym->set_domain (TYPE_DOMAIN);
+ }
/* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
really ever be static objects: otherwise, if you try
case DW_TAG_subrange_type:
case DW_TAG_generic_subrange:
sym->set_aclass_index (LOC_TYPEDEF);
- sym->set_domain (VAR_DOMAIN);
+ sym->set_domain (TYPE_DOMAIN);
list_to_add = cu->list_in_scope;
break;
case DW_TAG_enumerator:
+ sym->set_domain (VAR_DOMAIN);
attr = dwarf2_attr (die, DW_AT_const_value, cu);
if (attr != nullptr)
{
break;
case DW_TAG_imported_declaration:
case DW_TAG_namespace:
+ sym->set_domain (TYPE_DOMAIN);
sym->set_aclass_index (LOC_TYPEDEF);
list_to_add = cu->get_builder ()->get_global_symbols ();
break;
#define GDB_DWARF2_TAG_H
#include "dwarf2.h"
+#include "symtab.h"
/* Return true if TAG represents a type, false otherwise. */
}
}
+/* Return true if the given DWARF tag matches the specified search
+ domain flags. LANG may affect the result, due to the "C++ tag
+ hack". */
+
+static inline bool
+tag_matches_domain (dwarf_tag tag, domain_search_flags search, language lang)
+{
+ domain_search_flags flags = 0;
+ switch (tag)
+ {
+ case DW_TAG_variable:
+ case DW_TAG_enumerator:
+ case DW_TAG_constant:
+ flags = SEARCH_VAR_DOMAIN;
+ break;
+
+ case DW_TAG_subprogram:
+ case DW_TAG_entry_point:
+ flags = SEARCH_FUNCTION_DOMAIN;
+ break;
+
+ case DW_TAG_structure_type:
+ case DW_TAG_class_type:
+ case DW_TAG_union_type:
+ case DW_TAG_enumeration_type:
+ {
+ if (lang == language_c
+ || lang == language_objc
+ || lang == language_opencl
+ || lang == language_minimal)
+ flags = SEARCH_STRUCT_DOMAIN;
+ else if (lang == language_cplus)
+ flags = SEARCH_STRUCT_DOMAIN | SEARCH_TYPE_DOMAIN;
+ else
+ flags = SEARCH_TYPE_DOMAIN;
+ }
+ break;
+
+ case DW_TAG_padding:
+ case DW_TAG_array_type:
+ case DW_TAG_pointer_type:
+ case DW_TAG_reference_type:
+ case DW_TAG_string_type:
+ case DW_TAG_subroutine_type:
+ case DW_TAG_ptr_to_member_type:
+ case DW_TAG_set_type:
+ case DW_TAG_subrange_type:
+ case DW_TAG_base_type:
+ case DW_TAG_const_type:
+ case DW_TAG_packed_type:
+ case DW_TAG_template_type_param:
+ case DW_TAG_volatile_type:
+ case DW_TAG_restrict_type:
+ case DW_TAG_interface_type:
+ case DW_TAG_namespace:
+ case DW_TAG_unspecified_type:
+ case DW_TAG_shared_type:
+ case DW_TAG_rvalue_reference_type:
+ case DW_TAG_coarray_type:
+ case DW_TAG_dynamic_type:
+ case DW_TAG_atomic_type:
+ case DW_TAG_immutable_type:
+ case DW_TAG_typedef:
+ flags = SEARCH_TYPE_DOMAIN;
+ break;
+
+ case DW_TAG_label:
+ flags = SEARCH_LABEL_DOMAIN;
+ break;
+
+ case DW_TAG_module:
+ flags = SEARCH_MODULE_DOMAIN;
+ break;
+ }
+
+ return (flags & search) != 0;
+}
+
#endif /* GDB_DWARF2_TAG_H */
return make_qualified_type (type, instance_flags, NULL);
name = type->name ();
- /* FIXME: shouldn't we look in STRUCT_DOMAIN and/or
- VAR_DOMAIN as appropriate? */
if (name == NULL)
{
stub_noname_complaint ();
return make_qualified_type (type, instance_flags, NULL);
}
- sym = lookup_symbol (name, nullptr, SEARCH_STRUCT_DOMAIN,
- nullptr).symbol;
+ domain_search_flag flag
+ = ((type->language () == language_c
+ || type->language () == language_objc
+ || type->language () == language_opencl
+ || type->language () == language_minimal)
+ ? SEARCH_STRUCT_DOMAIN
+ : SEARCH_TYPE_DOMAIN);
+ sym = lookup_symbol (name, nullptr, flag, nullptr).symbol;
if (sym)
type->set_target_type (sym->type ());
else /* TYPE_CODE_UNDEF */
else if (type->is_stub () && !currently_reading_symtab)
{
const char *name = type->name ();
- /* FIXME: shouldn't we look in STRUCT_DOMAIN and/or VAR_DOMAIN
- as appropriate? */
struct symbol *sym;
if (name == NULL)
stub_noname_complaint ();
return make_qualified_type (type, instance_flags, NULL);
}
- sym = lookup_symbol (name, nullptr, SEARCH_STRUCT_DOMAIN,
- nullptr).symbol;
+ domain_search_flag flag
+ = ((type->language () == language_c
+ || type->language () == language_objc
+ || type->language () == language_opencl
+ || type->language () == language_minimal)
+ ? SEARCH_STRUCT_DOMAIN
+ : SEARCH_TYPE_DOMAIN);
+ sym = lookup_symbol (name, nullptr, flag, nullptr).symbol;
if (sym)
{
/* Same as above for opaque types, we can replace the stub
struct symbol *sym;
struct field_of_this_result is_a_field_of_this;
- sym = lookup_symbol (name, block, SEARCH_STRUCT_DOMAIN,
+ sym = lookup_symbol (name, block, SEARCH_TYPE_DOMAIN,
&is_a_field_of_this).symbol;
if (sym
new_block->set_end (gdb_block_iter.end);
/* The name. */
- block_name->set_domain (VAR_DOMAIN);
+ block_name->set_domain (FUNCTION_DOMAIN);
block_name->set_aclass_index (LOC_BLOCK);
block_name->set_symtab (filetab);
block_name->set_type (lookup_function_type (block_type));
symbol->set_is_objfile_owned (0);
symbol->set_section_index (0);
symbol->set_type (type);
- symbol->set_domain (VAR_DOMAIN);
+ symbol->set_domain (TYPE_DOMAIN);
symbol->set_aclass_index (LOC_TYPEDEF);
return symbol;
}
break;
}
s = new_symbol (name);
- s->set_domain (VAR_DOMAIN);
+ s->set_domain (FUNCTION_DOMAIN);
s->set_aclass_index (LOC_BLOCK);
s->set_section_index (section_index);
/* Type of the return value. */
if (has_opaque_xref (cur_fdr, sh))
break;
s = new_symbol (name);
- s->set_domain (VAR_DOMAIN);
+ s->set_domain (TYPE_DOMAIN);
s->set_aclass_index (LOC_TYPEDEF);
s->set_value_block (top_stack->cur_block);
s->set_type (t);
const struct block *block = pstate->expression_context_block;
munge_name_and_block (&name, &block);
- result = ::lookup_symbol (name, block, SEARCH_STRUCT_DOMAIN, NULL);
+ result = ::lookup_symbol (name, block, SEARCH_TYPE_DOMAIN, nullptr);
if (result.symbol != NULL)
{
update_innermost_block (result);
/* A static function definition. */
sym->set_type (read_type (&p, objfile));
sym->set_aclass_index (LOC_BLOCK);
- sym->set_domain (VAR_DOMAIN);
+ sym->set_domain (FUNCTION_DOMAIN);
add_symbol_to_list (sym, get_file_symbols ());
/* fall into process_function_types. */
/* A global function definition. */
sym->set_type (read_type (&p, objfile));
sym->set_aclass_index (LOC_BLOCK);
- sym->set_domain (VAR_DOMAIN);
+ sym->set_domain (FUNCTION_DOMAIN);
add_symbol_to_list (sym, get_global_symbols ());
goto process_function_types;
sym->set_aclass_index (LOC_TYPEDEF);
sym->set_value_longest (valu);
- sym->set_domain (VAR_DOMAIN);
+ sym->set_domain (TYPE_DOMAIN);
/* C++ vagaries: we may have a type which is derived from
a base type which did not have its name defined when the
derived class was output. We fill in the derived class's
*typedef_sym = *sym;
typedef_sym->set_aclass_index (LOC_TYPEDEF);
typedef_sym->set_value_longest (valu);
- typedef_sym->set_domain (VAR_DOMAIN);
+ typedef_sym->set_domain (TYPE_DOMAIN);
if (sym->type ()->name () == 0)
sym->type ()->set_name
(obconcat (&objfile->objfile_obstack, sym->linkage_name (),
DOMAIN (COMMON_BLOCK)
/* TYPE_DOMAIN is for types and typedefs. Note that tags are not
- found here, see STRUCT_DOMAIN above. */
+ found here, see STRUCT_DOMAIN above. If a language does not have a
+ tag namespace, then all types (including structures, etc) are
+ here. */
DOMAIN (TYPE)
bool
symbol::matches (domain_search_flags flags) const
{
- if (language () != language_c
- && language () != language_objc
- && language () != language_opencl)
- {
- /* Only C languages distinguish tag and type namespaces. */
- if ((flags & SEARCH_TYPE_DOMAIN) != 0)
- flags |= SEARCH_STRUCT_DOMAIN;
- }
-
- if ((flags & SEARCH_FUNCTION_DOMAIN) != 0
- && domain () == VAR_DOMAIN
- && aclass () == LOC_BLOCK)
- return true;
-
- if ((flags & SEARCH_VAR_DOMAIN) != 0
- && domain () == VAR_DOMAIN)
- return true;
-
- if ((flags & SEARCH_TYPE_DOMAIN) != 0
- && domain () == VAR_DOMAIN
- && aclass () == LOC_TYPEDEF)
- return true;
-
- if ((flags & SEARCH_STRUCT_DOMAIN) != 0
- && domain () == STRUCT_DOMAIN)
- return true;
+ /* C++ has a typedef for every tag, and the types are in the struct
+ domain. */
+ if (language () == language_cplus && (flags & SEARCH_TYPE_DOMAIN) != 0)
+ flags |= SEARCH_STRUCT_DOMAIN;
return search_flags_matches (flags, m_domain);
}
filenames, false))))
continue;
+ if (!sym->matches (kind))
+ continue;
+
if (preg.has_value () && !preg->exec (sym->natural_name (), 0,
nullptr, 0) == 0)
continue;
- bool matches = false;
- if (!matches && (kind & SEARCH_VAR_DOMAIN) != 0)
+ if (((sym->domain () == VAR_DOMAIN
+ || sym->domain () == FUNCTION_DOMAIN)
+ && treg.has_value ()
+ && !treg_matches_sym_type_name (*treg, sym)))
+ continue;
+
+ if ((kind & SEARCH_VAR_DOMAIN) != 0)
{
- if (sym->aclass () != LOC_TYPEDEF
- && sym->aclass () != LOC_UNRESOLVED
- && sym->aclass () != LOC_BLOCK
+ if (sym->aclass () == LOC_UNRESOLVED
/* LOC_CONST can be used for more than
just enums, e.g., c++ static const
members. We only want to skip enums
here. */
- && !(sym->aclass () == LOC_CONST
- && (sym->type ()->code ()
- == TYPE_CODE_ENUM))
- && (!treg.has_value ()
- || treg_matches_sym_type_name (*treg, sym)))
- matches = true;
- }
- if (!matches && (kind & SEARCH_FUNCTION_DOMAIN) != 0)
- {
- if (sym->aclass () == LOC_BLOCK
- && (!treg.has_value ()
- || treg_matches_sym_type_name (*treg,
- sym)))
- matches = true;
- }
- if (!matches && (kind & SEARCH_TYPE_DOMAIN) != 0)
- {
- if (sym->aclass () == LOC_TYPEDEF
- && sym->domain () != MODULE_DOMAIN)
- matches = true;
- }
- if (!matches && (kind & SEARCH_MODULE_DOMAIN) != 0)
- {
- if (sym->domain () == MODULE_DOMAIN
- && sym->line () != 0)
- matches = true;
+ || (sym->aclass () == LOC_CONST
+ && (sym->type ()->code () == TYPE_CODE_ENUM)))
+ continue;
}
- if (matches)
+ if (sym->domain () == MODULE_DOMAIN && sym->line () == 0)
+ continue;
+
+ if (result_set->size () < m_max_search_results)
{
- if (result_set->size () < m_max_search_results)
- {
- /* Match, insert if not already in the results. */
- symbol_search ss (block, sym);
- if (result_set->find (ss) == result_set->end ())
- result_set->insert (ss);
- }
- else
- return false;
+ /* Match, insert if not already in the results. */
+ symbol_search ss (block, sym);
+ if (result_set->find (ss) == result_set->end ())
+ result_set->insert (ss);
}
+ else
+ return false;
}
}
}
gdb_assert (block == GLOBAL_BLOCK || block == STATIC_BLOCK);
if (block == STATIC_BLOCK
- && sym->domain () == VAR_DOMAIN
- && sym->aclass () != LOC_TYPEDEF)
+ && (sym->domain () == VAR_DOMAIN
+ || sym->domain () == FUNCTION_DOMAIN))
str += "static ";
/* Typedef that is not a C++ class. */
- if (sym->domain () == VAR_DOMAIN && sym->aclass () == LOC_TYPEDEF)
+ if (sym->domain () == TYPE_DOMAIN)
{
string_file tmp_stream;
str += tmp_stream.string ();
}
/* variable, func, or typedef-that-is-c++-class. */
- else if (sym->domain () == VAR_DOMAIN || sym->domain () == STRUCT_DOMAIN)
+ else if (sym->domain () == VAR_DOMAIN || sym->domain () == STRUCT_DOMAIN
+ || sym->domain () == FUNCTION_DOMAIN)
{
string_file tmp_stream;
"${decimal}: record" \
" some_component_in_c: int;" \
"end record" ]
-set type_in_ada(c_syntax) "${decimal}: struct global_pack__some_type_in_ada;"
-set type_in_ada(ada_syntax) "${decimal}: global_pack.some_type_in_ada;"
+set type_in_ada(c_syntax) "${decimal}: struct global_pack__some_type_in_ada"
+set type_in_ada(ada_syntax) "${decimal}: global_pack.some_type_in_ada"
set var_in_c(c_syntax) "${decimal}: some_type_in_c some_struct_in_c;"
set var_in_c(ada_syntax) "${decimal}: some_struct_in_c: some_type_in_c;"
# crash.
set exp ".*"
}
- gdb_test "ptype/o struct prog__rec" $exp
+ gdb_test "ptype/o prog__rec" $exp
}
GDBInfoSymbols::check_optional_entry "${srcfile}" "" "${character1}"
GDBInfoSymbols::check_entry "${srcfile}" "" "${integer4}"
GDBInfoSymbols::check_entry "${srcfile}" "" "${logical4}"
-GDBInfoSymbols::check_entry "${srcfile}" "$decimal" "Type m1t1;"
+GDBInfoSymbols::check_entry "${srcfile}" "$decimal" "Type m1t1"
GDBInfoSymbols::check_entry "${srcfile}" "" "${real4}"
# The emission of the 'Type s1' at global scope is actually not expected. The
sym->set_linkage_name (SYMNAME_ALLOC (name, symname_alloced));
sym->set_type (builtin_type (objfile)->nodebug_text_symbol);
+ sym->set_domain (FUNCTION_DOMAIN);
sym->set_aclass_index (LOC_BLOCK);
sym2 = new (&objfile->objfile_obstack) symbol (*sym);
/* Also a typedef with the same name. */
pst->add_psymbol (std::string_view (namestring,
p - namestring),
- true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ true, TYPE_DOMAIN, LOC_TYPEDEF, -1,
psymbol_placement::STATIC,
unrelocated_addr (0),
psymtab_language,
{
pst->add_psymbol (std::string_view (namestring,
p - namestring),
- true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ true, TYPE_DOMAIN, LOC_TYPEDEF, -1,
psymbol_placement::STATIC,
unrelocated_addr (0),
psymtab_language,
}
pst->add_psymbol (std::string_view (namestring,
p - namestring),
- true, VAR_DOMAIN, LOC_BLOCK,
+ true, FUNCTION_DOMAIN, LOC_BLOCK,
SECT_OFF_TEXT (objfile),
psymbol_placement::STATIC,
unrelocated_addr (symbol.n_value),
pst->add_psymbol (std::string_view (namestring,
p - namestring),
- true, VAR_DOMAIN, LOC_BLOCK,
+ true, FUNCTION_DOMAIN, LOC_BLOCK,
SECT_OFF_TEXT (objfile),
psymbol_placement::GLOBAL,
unrelocated_addr (symbol.n_value),
projects / thirdparty / binutils-gdb.git / commitdiff
