This commit implements the missing support for [[N]]::'file.c'::var
syntax that was skipped on the previous commit. This is done with a new
rule, 'block: block COLONCOLON FILENAME', a few changes to
classify_name and adding a value to the parser_state.
classify_name now restricts its search for files to ones available in
the provided linker namespace (if there was one), which is found in the
parser_state. To explain why the search has to be restricted, imagine
the following scenario: An inferior has 2 linker namespaces. In
namespace 0, there is a library with the file 'foo' loaded; in namespace
1, there is a function 'foo', which is in the stack. If the user were to
type [[1]]::foo::var, it could be possible that foo is mis-classified as
a filename, then when executing the rule 'block: block COLONCOLON FILENAME'
we search for the file with the filename restriction and error out because
there are no files named that. Therefore, the safest way to ensure we're
always classifying things correctly is to use the linker namespace in the
classify_name function. And the reason the linker namespace must be in
the parser_state is because, while running classify_name, we don't have
access to the previous states to see if there was a LINKER_NAMESPACE
token, so adding it to the global state is the only way to pass it
along.
The new rule only exists to make sure that it is only used in the
intended syntax, instead of allowing for something like
function::filename::variable.
This commit also adds a link to the solib_ops relevant
to the expression being parsed, as a way to identify if linker
namespaces are supported; this could be achieved by guarding the search
functions instead, but I think that this is more reliable.
The new rule uses "block" rather than a linker namespace specific token,
because if we allowed that token to also reduce into block, the new rule
would never be triggered as the simple reduction would be preferred. If
we didn't allow the linker namespace to reduce into block, the rest of
the syntaxes for [[N]]::foo would be more involved, so the option in
this commit seemed like the simplest solution.
The rule "block: block COLONCOLON name" also had to be updated because,
if a user tried to search for a file not present in the linker
namespace, GDB would miscategorize it to 'name' instead of 'filename',
and if no function of the same name was found, the error would only say
"No function \"foo\" (...)" which could confuse a user. The new error
says "Nothing named \"foo\" (...)" instead since it is impossible for us
to disambiguate between filename or function name, and both would be
valid in this code path.
The parser_state changes were not used for the previous commit because
the lookup_symbol calls would lead to an even more intrusive change for
no real gain, since the search would be rerun any way. There is an
argument to be made that the results could be different if only
namespace had a type and another had a variable, but a situation where
that significantly changes the result is quite unlikely, I think.
---
gdb/c-exp.y | 23 ++++++++++--
gdb/linespec.c | 4 +--
gdb/parse.c | 3 +-
gdb/parser-defs.h | 37 ++++++++++++++++++--
gdb/rust-parse.c | 3 +-
gdb/symtab.c | 37 +++++++++++++-------
gdb/symtab.h | 4 ++-
gdb/testsuite/gdb.base/dlmopen-ns-ids-main.c | 2 ++
gdb/testsuite/gdb.base/dlmopen-ns-ids.exp | 21 +++++++++++
9 files changed, 112 insertions(+), 22 deletions(-)
@@ -1064,15 +1064,18 @@ block : BLOCKNAME
copy_name ($1.stoken).c_str ());
$$.search_namespace = false;
$$.b_val = $1.sym.symbol->value_block ();
+ pstate->reset_linker_namespace ();
}
| FILENAME
{
$$ = $1;
+ pstate->reset_linker_namespace ();
}
| DOUBLESQUAREOPEN INT DOUBLESQUARECLOSE
{
$$.search_namespace = true;
$$.namespace_val = $2.val;
+ pstate->set_linker_namespace ($2.val);
}
;
@@ -1089,12 +1092,26 @@ block : block COLONCOLON name
SEARCH_FUNCTION_DOMAIN,
nullptr);
- if (tem.symbol == nullptr)
+ if (tem.symbol == nullptr && !$1.search_namespace)
error (_("No function \"%ps\" in specified context."),
styled_string (function_name_style.style (),
copy.c_str ()));
+ else if (tem.symbol == nullptr && $1.search_namespace)
+ /* COPY can be a function or a file. There is no way
+ to identify which the user intended, so emit a
+ generic warning instead. */
+ error (_("Nothing named \"%s\" in specified context."),
+ copy.c_str ());
$$.b_val = tem.symbol->value_block ();
$$.search_namespace = false;
+ pstate->reset_linker_namespace ();
+ }
+ | block COLONCOLON FILENAME
+ {
+ if (!$1.search_namespace)
+ error (_("Filename must be the first part of the expression"));
+ $$ = $3;
+ pstate->reset_linker_namespace ();
}
;
@@ -1131,6 +1148,7 @@ variable: block COLONCOLON name
pstate->block_tracker->update (sym);
pstate->push_new<var_value_operation> (sym);
+ pstate->reset_linker_namespace ();
}
;
@@ -3207,7 +3225,8 @@ classify_name (struct parser_state *par_state, const struct block *block,
|| is_quoted_name)
{
/* See if it's a file name. */
- if (auto symtab = lookup_symtab (current_program_space, copy.c_str ());
+ if (auto symtab = lookup_symtab (current_program_space, copy.c_str (),
+ par_state->get_linker_namespace ());
symtab != nullptr)
{
yylval.bval.b_val
@@ -3628,11 +3628,11 @@ collect_symtabs_from_filename (const char *file,
if (pspace->executing_startup)
continue;
- for_each_symtab (pspace, file, collector);
+ for_each_symtab (pspace, file, -1, collector);
}
}
else
- for_each_symtab (search_pspace, file, collector);
+ for_each_symtab (search_pspace, file, -1, collector);
/* It is tempting to use the unordered_dense 'extract' method here,
and remove the separate vector -- but it's unclear if ordering
@@ -426,7 +426,8 @@ parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
parser_state ps (lang, get_current_arch (), expression_context_block,
expression_context_pc, flags, *stringptr,
- completer != nullptr, tracker);
+ completer != nullptr, tracker,
+ current_program_space->solib_ops ());
scoped_restore_current_language lang_saver (lang->la_language);
@@ -26,6 +26,7 @@
#include "expression.h"
#include "symtab.h"
#include "expop.h"
+#include "solib.h"
struct block;
struct language_defn;
@@ -147,7 +148,8 @@ struct parser_state : public expr_builder
parser_flags flags,
const char *input,
bool completion,
- innermost_block_tracker *tracker)
+ innermost_block_tracker *tracker,
+ const solib_ops *ops)
: expr_builder (lang, gdbarch),
expression_context_block (context_block),
expression_context_pc (context_pc),
@@ -157,7 +159,8 @@ struct parser_state : public expr_builder
comma_terminates ((flags & PARSER_COMMA_TERMINATES) != 0),
parse_completion (completion),
void_context_p ((flags & PARSER_VOID_CONTEXT) != 0),
- debug ((flags & PARSER_DEBUG) != 0)
+ debug ((flags & PARSER_DEBUG) != 0),
+ m_solib_ops (ops)
{
}
@@ -267,6 +270,26 @@ struct parser_state : public expr_builder
push (expr::make_operation<T> (std::move (lhs), std::move (rhs)));
}
+ void set_linker_namespace (LONGEST ns_id)
+ {
+ if (m_solib_ops == nullptr)
+ error (_("Linker namespaces require an active inferior"));
+ if (m_solib_ops->supports_namespaces ())
+ m_linker_namespace = ns_id;
+ else
+ error (_("Linker namespaces are not supported"));
+ }
+
+ void reset_linker_namespace ()
+ {
+ m_linker_namespace = -1;
+ }
+
+ LONGEST get_linker_namespace () const
+ {
+ return m_linker_namespace;
+ }
+
/* Function called from the various parsers' yyerror functions to throw
an error. The error will include a message identifying the location
of the error within the current expression. */
@@ -327,6 +350,16 @@ struct parser_state : public expr_builder
/* Stack of operations. */
std::vector<expr::operation_up> m_operations;
+
+ /* If the expression is being restricted to a specific namespace, this is
+ where that information is stored for the block lookup. It should be
+ accessed through setter/getters to ensure that the linker namespace is
+ only set when the gdbarch supports it. */
+ LONGEST m_linker_namespace = -1;
+
+ /* Used to figure out if an inferior is capable of handling linker
+ namespaces at all. */
+ const solib_ops *m_solib_ops;
};
/* A string token, either a char-string or bit-string. Char-strings are
@@ -2305,7 +2305,8 @@ rust_lex_tests (void)
{
/* Set up dummy "parser", so that rust_type works. */
parser_state ps (language_def (language_rust), current_inferior ()->arch (),
- nullptr, 0, 0, nullptr, 0, nullptr);
+ nullptr, 0, 0, nullptr, 0, nullptr,
+ current_program_space->solib_ops ());
rust_parser parser (&ps);
rust_lex_test_one (&parser, "", 0);
@@ -630,14 +630,11 @@ compare_filenames_for_search (const char *filename, const char *search_name)
&& STRIP_DRIVE_SPEC (filename) == &filename[len - search_len]));
}
-/* Return the first symtab in PSPACE matching NAME and for which
- CALLBACK returns true.
-
- See documentation for for_each_symtab for how exactly NAME is matched. */
+/* See symtab.h. */
static symtab *
find_symtab (program_space *pspace, const char *name,
- find_symtab_callback_ftype callback)
+ LONGEST linker_ns, find_symtab_callback_ftype callback)
{
gdb::unique_xmalloc_ptr<char> real_path;
@@ -649,10 +646,23 @@ find_symtab (program_space *pspace, const char *name,
gdb_assert (IS_ABSOLUTE_PATH (real_path.get ()));
}
- for (objfile &objfile : pspace->objfiles ())
+ std::vector<objfile *> objfiles_to_search;
+ if (linker_ns >= 0)
+ {
+ gdb_assert (pspace->solib_ops ()->supports_namespaces ());
+ objfiles_to_search
+ = get_objfiles_in_linker_namespace (linker_ns, pspace);
+ }
+ else
+ {
+ for (objfile &objf : pspace->objfiles ())
+ objfiles_to_search.push_back (&objf);
+ }
+
+ for (objfile *objfile : objfiles_to_search)
if (symtab *result
- = objfile.find_symtab_matching_filename (name, real_path.get (),
- callback);
+ = objfile->find_symtab_matching_filename (name, real_path.get (),
+ callback);
result != nullptr)
return result;
@@ -663,9 +673,9 @@ find_symtab (program_space *pspace, const char *name,
void
for_each_symtab (program_space *pspace, const char *name,
- for_each_symtab_callback_ftype callback)
+ LONGEST linker_ns, for_each_symtab_callback_ftype callback)
{
- find_symtab (pspace, name, [&] (symtab *symtab)
+ find_symtab (pspace, name, linker_ns, [&] (symtab *symtab)
{
callback (symtab);
return false;
@@ -675,9 +685,10 @@ for_each_symtab (program_space *pspace, const char *name,
/* See symtab.h. */
symtab *
-lookup_symtab (program_space *pspace, const char *name)
+lookup_symtab (program_space *pspace, const char *name, LONGEST linker_ns)
{
- return find_symtab (pspace, name, [&] (symtab *symtab) { return true; });
+ return find_symtab (pspace, name, linker_ns,
+ [&] (symtab *symtab) { return true; });
}
@@ -6192,7 +6203,7 @@ collect_file_symbol_completion_matches (completion_tracker &tracker,
/* Go through symtabs for SRCFILE and check the externs and statics
for symbols which match. */
- for_each_symtab (current_program_space, srcfile, [&] (symtab *s)
+ for_each_symtab (current_program_space, srcfile, -1, [&] (symtab *s)
{
add_symtab_completions (s->compunit (),
tracker, mode, lookup_name,
@@ -2074,7 +2074,8 @@ const char *multiple_symbols_select_mode (void);
/* Lookup a symbol table in PSPACE by source file name. */
-extern symtab *lookup_symtab (program_space *pspace, const char *name);
+extern symtab *lookup_symtab (program_space *pspace, const char *name,
+ LONGEST linker_ns = -1);
/* An object of this type is passed as the 'is_a_field_of_this'
argument to lookup_symbol and lookup_symbol_in_language. */
@@ -2806,6 +2807,7 @@ using for_each_symtab_callback_ftype = std::function<void (symtab *)>;
Call CALLBACK with each symtab that is found. */
void for_each_symtab (program_space *pspace, const char *name,
+ LONGEST linker_ns,
for_each_symtab_callback_ftype callback);
/* Callback type for function find_symtab. */
@@ -24,6 +24,8 @@
#include <unistd.h>
#include <stdio.h>
+int global_main_file = 1312;
+
int
main (void)
{
@@ -321,9 +321,15 @@ proc_with_prefix test_print_namespace_symbol {} {
clean_restart
gdb_load $::binfile
+ set ns0 [ns_id_for_command 0]
set ns1 [ns_id_for_command 1]
set ns2 [ns_id_for_command 2]
+ # Test printing variables before starting the inferior
+ gdb_test "print ${ns1}::gdb_dlmopen_glob" \
+ "Linker namespaces require an active inferior" \
+ "Before starting inferior"
+
if { ![runto_main] } {
return
}
@@ -355,12 +361,27 @@ proc_with_prefix test_print_namespace_symbol {} {
gdb_test "print ${ns2}::func_with_other_call::n" \
"No frame is currently executing in block func_with_other_call."
+ # Test that complex expressions work with multiple namespaces.
+ # At this point, the global in namespace 1 is 0, and in namespace 2 is 1
+ # and the current namespace is 1.
+ gdb_test "print ${ns2}::gdb_dlmopen_glob + gdb_dlmopen_glob" ".* = 1"
+ gdb_test "print ${ns2}::'${::srcfile_lib}'::gdb_dlmopen_glob + gdb_dlmopen_glob" \
+ ".* = 1"
+ gdb_test "print ${ns2}::'${::srcfile_lib}'::gdb_dlmopen_glob + '${::srcfile}'::global_main_file" \
+ ".* = 1312"
+
# Leave to default namespace.
gdb_continue_to_breakpoint "TAG: first dlclose"
# This global doesn't exist in the default namespace. Rather than
# returning a random one, we just say we didn't find one.
gdb_test "print gdb_dlmopen_glob" \
"No symbol .gdb_dlmopen_glob. in the current linker namespace."
+
+ # Minimal testing for finding files in namespaces.
+ gdb_test "print ${ns1}::'${::srcfile_lib}'::gdb_dlmopen_glob" \
+ ".* = 2"
+ gdb_test "print ${ns0}::'${::srcfile_lib}'::gdb_dlmopen_glob" \
+ "Nothing named .${::srcfile_lib}. in specified context."
}
test_info_shared