void operator() (struct block_symbol *bsym);
- void finish (const block *block);
-
struct objfile *objfile = nullptr;
std::vector<struct block_symbol> *resultp;
- struct symbol *arg_sym = nullptr;
- bool found_sym = false;
};
-/* Finish iteration over one block. If a symbol hasn't been found
- already, add 'arg_sym' to the list of symbols. */
-
-void
-match_data::finish (const block *block)
-{
- if (!found_sym && arg_sym != nullptr)
- add_defn_to_vec (*resultp, arg_sym, block);
- found_sym = false;
- arg_sym = nullptr;
-}
-
/* A callback for add_nonlocal_symbols that adds symbol, found in
BSYM, to a list of symbols. */
if (sym->loc_class () == LOC_UNRESOLVED)
return;
- else if (sym->is_argument ())
- arg_sym = sym;
else
- {
- found_sym = true;
- add_defn_to_vec (*resultp, sym, block);
- }
+ add_defn_to_vec (*resultp, sym, block);
}
/* Helper for add_nonlocal_symbols. Find symbols in DOMAIN which are
targeted by renamings matching LOOKUP_NAME in BLOCK. Add these
- symbols to RESULT. Return whether we found such symbols. */
+ symbols to RESULT. */
-static bool
+static void
ada_add_block_renamings (std::vector<struct block_symbol> &result,
const struct block *block,
const lookup_name_info &lookup_name,
domain_search_flags domain)
{
- int defns_mark = result.size ();
-
symbol_name_matcher_ftype *name_match
= ada_get_symbol_name_matcher (lookup_name);
1, NULL);
}
}
- return result.size () != defns_mark;
}
/* Convenience function to get at the Ada encoded lookup name for
const struct block *block
= symtab->blockvector ()->block (block_kind);
for_each_symbol (block, lookup_name, domain, data);
- data.finish (block);
return iteration_status::keep_going;
};
const struct block *global_block
= cu.blockvector ()->global_block ();
- if (ada_add_block_renamings (result, global_block, lookup_name,
- domain))
- data.found_sym = true;
+ ada_add_block_renamings (result, global_block, lookup_name, domain);
}
}
const lookup_name_info &lookup_name,
domain_search_flags domain, struct objfile *objfile)
{
- /* A matching argument symbol, if any. */
- struct symbol *arg_sym;
- /* Set true when we find a matching non-argument symbol. */
- bool found_sym;
-
- arg_sym = NULL;
- found_sym = false;
for (struct symbol *sym : block_iterator_range (block, &lookup_name))
{
- if (sym->matches (domain))
- {
- if (sym->loc_class () != LOC_UNRESOLVED)
- {
- if (sym->is_argument ())
- arg_sym = sym;
- else
- {
- found_sym = true;
- add_defn_to_vec (result, sym, block);
- }
- }
- }
+ if (sym->matches (domain) && sym->loc_class () != LOC_UNRESOLVED)
+ add_defn_to_vec (result, sym, block);
}
/* Handle renamings. */
- if (ada_add_block_renamings (result, block, lookup_name, domain))
- found_sym = true;
-
- if (!found_sym && arg_sym != NULL)
- {
- add_defn_to_vec (result, arg_sym, block);
- }
+ ada_add_block_renamings (result, block, lookup_name, domain);
if (!lookup_name.ada ().wild_match_p ())
{
- arg_sym = NULL;
- found_sym = false;
const std::string &ada_lookup_name = lookup_name.ada ().lookup_name ();
const char *name = ada_lookup_name.c_str ();
size_t name_len = ada_lookup_name.size ();
&& is_name_suffix (sym->linkage_name () + name_len + 5))
{
if (sym->loc_class () != LOC_UNRESOLVED)
- {
- if (sym->is_argument ())
- arg_sym = sym;
- else
- {
- found_sym = true;
- add_defn_to_vec (result, sym, block);
- }
- }
+ add_defn_to_vec (result, sym, block);
}
}
}
-
- /* NOTE: This really shouldn't be needed for _ada_ symbols.
- They aren't parameters, right? */
- if (!found_sym && arg_sym != NULL)
- {
- add_defn_to_vec (result, arg_sym, block);
- }
}
}
\f
block_lookup_symbol (const struct block *block, const lookup_name_info &name,
const domain_search_flags domain)
{
- if (!block->function ())
- {
- best_symbol_tracker tracker;
- tracker.search (nullptr, block, name, domain);
- return tracker.currently_best.symbol;
- }
- else
- {
- /* Note that parameter symbols do not always show up last in the
- list; this loop makes sure to take anything else other than
- parameter symbols first; it only uses parameter symbols as a
- last resort. Note that this only takes up extra computation
- time on a match.
- It's hard to define types in the parameter list (at least in
- C/C++) so we don't do the same PR 16253 hack here that is done
- for the !BLOCK_FUNCTION case. */
-
- struct symbol *sym_found = NULL;
-
- for (struct symbol *sym : block_iterator_range (block, &name))
- {
- if (sym->matches (domain))
- {
- sym_found = sym;
- if (!sym->is_argument ())
- {
- break;
- }
- }
- }
- return (sym_found); /* Will be NULL if not found. */
- }
+ best_symbol_tracker tracker;
+ tracker.search (nullptr, block, name, domain);
+ return tracker.currently_best.symbol;
}
/* See block.h. */
}
if (print_me)
{
- struct symbol *sym2;
struct frame_arg arg, entryarg;
- if (sym->is_argument ())
- sym2 = (lookup_symbol_search_name
- (sym->search_name (),
- block, SEARCH_VAR_DOMAIN).symbol);
- else
- sym2 = sym;
- gdb_assert (sym2 != NULL);
-
- arg.sym = sym2;
+ arg.sym = sym;
arg.entry_kind = print_entry_values_no;
- entryarg.sym = sym2;
+ entryarg.sym = sym;
entryarg.entry_kind = print_entry_values_no;
switch (values)
{
case PRINT_SIMPLE_VALUES:
- if (!mi_simple_type_p (sym2->type ()))
+ if (!mi_simple_type_p (sym->type ()))
break;
[[fallthrough]];
case PRINT_ALL_VALUES:
if (sym->is_argument ())
- read_frame_arg (fp_opts, sym2, fi, &arg, &entryarg);
+ read_frame_arg (fp_opts, sym, fi, &arg, &entryarg);
else
- read_frame_local (sym2, fi, &arg);
+ read_frame_local (sym, fi, &arg);
break;
}
break;
}
- /* We have to look up the symbol because arguments can have
- two entries (one a parameter, one a local) and the one we
- want is the local, which lookup_symbol will find for us.
- This includes gcc1 (not gcc2) on SPARC when passing a
- small structure and gcc2 when the argument type is float
- and it is passed as a double and converted to float by
- the prologue (in the latter case the type of the LOC_ARG
- symbol is double and the type of the LOC_LOCAL symbol is
- float). */
- /* But if the parameter name is null, don't try it. Null
- parameter names occur on the RS/6000, for traceback
- tables. FIXME, should we even print them? */
-
- if (*sym->linkage_name ())
- {
- struct symbol *nsym;
-
- nsym = lookup_symbol_search_name (sym->search_name (),
- b, SEARCH_VAR_DOMAIN).symbol;
- gdb_assert (nsym != NULL);
- if (nsym->loc_class () == LOC_REGISTER
- && !nsym->is_argument ())
- {
- /* There is a LOC_ARG/LOC_REGISTER pair. This means
- that it was passed on the stack and loaded into a
- register, or passed in a register and stored in a
- stack slot. GDB 3.x used the LOC_ARG; GDB
- 4.0-4.11 used the LOC_REGISTER.
-
- Reasons for using the LOC_ARG:
-
- (1) Because find_saved_registers may be slow for
- remote debugging.
-
- (2) Because registers are often reused and stack
- slots rarely (never?) are. Therefore using
- the stack slot is much less likely to print
- garbage.
-
- Reasons why we might want to use the LOC_REGISTER:
-
- (1) So that the backtrace prints the same value
- as "print foo". I see no compelling reason
- why this needs to be the case; having the
- backtrace print the value which was passed
- in, and "print foo" print the value as
- modified within the called function, makes
- perfect sense to me.
-
- Additional note: It might be nice if "info args"
- displayed both values.
-
- One more note: There is a case with SPARC
- structure passing where we need to use the
- LOC_REGISTER, but this is dealt with by creating
- a single LOC_REGPARM in symbol reading. */
-
- /* Leave sym (the LOC_ARG) alone. */
- ;
- }
- else
- sym = nsym;
- }
-
/* Print the current arg. */
if (!first)
uiout->text (", ");
{
/* Don't worry about things which aren't arguments. */
if (sym->is_argument ())
- {
- /* We have to look up the symbol because arguments can have
- two entries (one a parameter, one a local) and the one we
- want is the local, which lookup_symbol will find for us.
- This includes gcc1 (not gcc2) on the sparc when passing a
- small structure and gcc2 when the argument type is float
- and it is passed as a double and converted to float by
- the prologue (in the latter case the type of the LOC_ARG
- symbol is double and the type of the LOC_LOCAL symbol is
- float). There are also LOC_ARG/LOC_REGISTER pairs which
- are not combined in symbol-reading. */
-
- struct symbol *sym2
- = lookup_symbol_search_name (sym->search_name (),
- b, SEARCH_VAR_DOMAIN).symbol;
- cb (sym->print_name (), sym2);
- }
+ cb (sym->print_name (), sym);
}
}
projects / thirdparty / binutils-gdb.git / commitdiff
