/* List lines of source files for GDB, the GNU debugger.
- Copyright (C) 1986-2019 Free Software Foundation, Inc.
+ Copyright (C) 1986-2021 Free Software Foundation, Inc.
This file is part of GDB.
#include "filenames.h" /* for DOSish file names */
#include "completer.h"
#include "ui-out.h"
-#include "readline/readline.h"
+#include "readline/tilde.h"
#include "gdbsupport/enum-flags.h"
#include "gdbsupport/scoped_fd.h"
#include <algorithm>
#include "gdbsupport/pathstuff.h"
#include "source-cache.h"
#include "cli/cli-style.h"
+#include "observable.h"
+#include "build-id.h"
+#include "debuginfod-support.h"
#define OPEN_MODE (O_RDONLY | O_BINARY)
#define FDOPEN_MODE FOPEN_RB
static struct substitute_path_rule *substitute_path_rules = NULL;
-/* Symtab of default file for listing lines of. */
+/* An instance of this is attached to each program space. */
-static struct symtab *current_source_symtab;
+struct current_source_location
+{
+public:
+
+ current_source_location () = default;
+
+ /* Set the value. */
+ void set (struct symtab *s, int l)
+ {
+ m_symtab = s;
+ m_line = l;
+ gdb::observers::current_source_symtab_and_line_changed.notify ();
+ }
+
+ /* Get the symtab. */
+ struct symtab *symtab () const
+ {
+ return m_symtab;
+ }
+
+ /* Get the line number. */
+ int line () const
+ {
+ return m_line;
+ }
+
+private:
-/* Default next line to list. */
+ /* Symtab of default file for listing lines of. */
-static int current_source_line;
+ struct symtab *m_symtab = nullptr;
-static struct program_space *current_source_pspace;
+ /* Default next line to list. */
+
+ int m_line = 0;
+};
+
+static program_space_key<current_source_location> current_source_key;
/* Default number of lines to print with commands like "list".
This is based on guessing how many long (i.e. more than chars_per_line
return lines_to_list;
}
+/* A helper to return the current source location object for PSPACE,
+ creating it if it does not exist. */
+
+static current_source_location *
+get_source_location (program_space *pspace)
+{
+ current_source_location *loc
+ = current_source_key.get (pspace);
+ if (loc == nullptr)
+ loc = current_source_key.emplace (pspace);
+ return loc;
+}
+
/* Return the current source file for listing and next line to list.
NOTE: The returned sal pc and end fields are not valid. */
get_current_source_symtab_and_line (void)
{
symtab_and_line cursal;
+ current_source_location *loc = get_source_location (current_program_space);
- cursal.pspace = current_source_pspace;
- cursal.symtab = current_source_symtab;
- cursal.line = current_source_line;
+ cursal.pspace = current_program_space;
+ cursal.symtab = loc->symtab ();
+ cursal.line = loc->line ();
cursal.pc = 0;
cursal.end = 0;
error (_("No symbol table is loaded. Use the \"file\" command."));
/* Pull in a current source symtab if necessary. */
- if (current_source_symtab == 0)
+ current_source_location *loc = get_source_location (current_program_space);
+ if (loc->symtab () == nullptr)
select_source_symtab (0);
}
{
symtab_and_line cursal;
- cursal.pspace = current_source_pspace;
- cursal.symtab = current_source_symtab;
- cursal.line = current_source_line;
+ current_source_location *loc = get_source_location (sal.pspace);
+
+ cursal.pspace = sal.pspace;
+ cursal.symtab = loc->symtab ();
+ cursal.line = loc->line ();
cursal.pc = 0;
cursal.end = 0;
- current_source_pspace = sal.pspace;
- current_source_symtab = sal.symtab;
- current_source_line = sal.line;
+ loc->set (sal.symtab, sal.line);
/* Force the next "list" to center around the current line. */
clear_lines_listed_range ();
void
clear_current_source_symtab_and_line (void)
{
- current_source_symtab = 0;
- current_source_line = 0;
+ current_source_location *loc = get_source_location (current_program_space);
+ loc->set (nullptr, 0);
}
/* See source.h. */
{
if (s)
{
- current_source_symtab = s;
- current_source_line = 1;
- current_source_pspace = SYMTAB_PSPACE (s);
+ current_source_location *loc
+ = get_source_location (SYMTAB_PSPACE (s));
+ loc->set (s, 1);
return;
}
- if (current_source_symtab)
+ current_source_location *loc = get_source_location (current_program_space);
+ if (loc->symtab () != nullptr)
return;
/* Make the default place to list be the function `main'
if (bsym.symbol != nullptr && SYMBOL_CLASS (bsym.symbol) == LOC_BLOCK)
{
symtab_and_line sal = find_function_start_sal (bsym.symbol, true);
- current_source_pspace = sal.pspace;
- current_source_symtab = sal.symtab;
- current_source_line = std::max (sal.line - (lines_to_list - 1), 1);
+ if (sal.symtab == NULL)
+ /* We couldn't find the location of `main', possibly due to missing
+ line number info, fall back to line 1 in the corresponding file. */
+ loc->set (symbol_symtab (bsym.symbol), 1);
+ else
+ loc->set (sal.symtab, std::max (sal.line - (lines_to_list - 1), 1));
return;
}
/* Alright; find the last file in the symtab list (ignoring .h's
and namespace symtabs). */
- current_source_line = 1;
+ struct symtab *new_symtab = nullptr;
for (objfile *ofp : current_program_space->objfiles ())
{
if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
|| strcmp (name, "<<C++-namespaces>>") == 0)))
- {
- current_source_pspace = current_program_space;
- current_source_symtab = symtab;
- }
+ new_symtab = symtab;
}
}
}
- if (current_source_symtab)
+ loc->set (new_symtab, 1);
+ if (new_symtab != nullptr)
return;
for (objfile *objfile : current_program_space->objfiles ())
{
- if (objfile->sf)
- s = objfile->sf->qf->find_last_source_symtab (objfile);
+ s = objfile->find_last_source_symtab ();
if (s)
- current_source_symtab = s;
+ new_symtab = s;
+ }
+ if (new_symtab != nullptr)
+ {
+ loc->set (new_symtab,1);
+ return;
}
- if (current_source_symtab)
- return;
error (_("Can't find a default source file"));
}
}
}
- if (objfile->sf)
- objfile->sf->qf->forget_cached_source_info (objfile);
+ objfile->forget_cached_source_info ();
}
/* See source.h. */
void
forget_cached_source_info (void)
{
- struct program_space *pspace;
-
- ALL_PSPACES (pspace)
+ for (struct program_space *pspace : program_spaces)
for (objfile *objfile : pspace->objfiles ())
{
forget_cached_source_info_for_objfile (objfile);
static void
directory_command (const char *dirname, int from_tty)
{
+ bool value_changed = false;
dont_repeat ();
/* FIXME, this goes to "delete dir"... */
if (dirname == 0)
{
xfree (source_path);
init_source_path ();
+ value_changed = true;
}
}
else
{
mod_path (dirname, &source_path);
forget_cached_source_info ();
+ value_changed = true;
+ }
+ if (value_changed)
+ {
+ gdb::observers::command_param_changed.notify ("directories", source_path);
+ if (from_tty)
+ show_directories_1 ((char *) 0, from_tty);
}
- if (from_tty)
- show_directories_1 ((char *) 0, from_tty);
}
/* Add a path given with the -d command line switch.
gdb::unique_xmalloc_ptr<char> new_name_holder;
/* Spaces and tabs will have been removed by buildargv().
- NAME is the start of the directory.
+ NAME is the start of the directory.
P is the '\0' following the end. */
p = name + strlen (name);
/* On MS-DOS and MS-Windows, h:\ is different from h: */
&& !(p == name + 3 && name[1] == ':') /* "d:/" */
#endif
+ && p > name
&& IS_DIR_SEPARATOR (p[-1]))
/* Sigh. "foo/" => "foo" */
--p;
break;
}
+ if (name[0] == '\0')
+ goto skip_dup;
if (name[0] == '~')
new_name_holder.reset (tilde_expand (name));
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
new_name_holder.reset (concat (name, ".", (char *) NULL));
#endif
else if (!IS_ABSOLUTE_PATH (name) && name[0] != '$')
- new_name_holder.reset (concat (current_directory, SLASH_STRING, name,
- (char *) NULL));
+ new_name_holder = gdb_abspath (name);
else
new_name_holder.reset (savestring (name, p - name));
name = new_name_holder.get ();
static void
info_source_command (const char *ignore, int from_tty)
{
- struct symtab *s = current_source_symtab;
+ current_source_location *loc
+ = get_source_location (current_program_space);
+ struct symtab *s = loc->symtab ();
struct compunit_symtab *cust;
if (!s)
letters (for dos) as well as leading '/' characters and './'
sequences. */
-const char *
+static const char *
prepare_path_for_appending (const char *path)
{
/* For dos paths, d:/foo -> /foo, and d:foo -> foo. */
static int
substitute_path_rule_matches (const struct substitute_path_rule *rule,
- const char *path)
+ const char *path)
{
const int from_len = strlen (rule->from);
const int path_len = strlen (path);
if (*fullname)
{
/* The user may have requested that source paths be rewritten
- according to substitution rules he provided. If a substitution
- rule applies to this path, then apply it. */
+ according to substitution rules he provided. If a substitution
+ rule applies to this path, then apply it. */
gdb::unique_xmalloc_ptr<char> rewritten_fullname
= rewrite_source_path (fullname->get ());
result = gdb_open_cloexec (fullname->get (), OPEN_MODE, 0);
if (result >= 0)
{
- if (basenames_may_differ)
- *fullname = gdb_realpath (fullname->get ());
- else
- *fullname = gdb_abspath (fullname->get ());
+ *fullname = gdb_realpath (fullname->get ());
return scoped_fd (result);
}
if (dirname != NULL)
{
/* If necessary, rewrite the compilation directory name according
- to the source path substitution rules specified by the user. */
+ to the source path substitution rules specified by the user. */
rewritten_dirname = rewrite_source_path (dirname);
if (rewritten_filename != NULL)
filename = rewritten_filename.get ();
- openp_flags flags = OPF_SEARCH_IN_PATH;
- if (basenames_may_differ)
- flags |= OPF_RETURN_REALPATH;
-
/* Try to locate file using filename. */
- result = openp (path, flags, filename, OPEN_MODE, fullname);
+ result = openp (path, OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH, filename,
+ OPEN_MODE, fullname);
if (result < 0 && dirname != NULL)
{
/* Remove characters from the start of PATH that we don't need when
cdir_filename.append (SLASH_STRING);
cdir_filename.append (filename_start);
- result = openp (path, flags, cdir_filename.c_str (), OPEN_MODE,
- fullname);
+ result = openp (path, OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH,
+ cdir_filename.c_str (), OPEN_MODE, fullname);
}
if (result < 0)
{
/* Didn't work. Try using just the basename. */
p = lbasename (filename);
if (p != filename)
- result = openp (path, flags, p, OPEN_MODE, fullname);
+ result = openp (path, OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH, p,
+ OPEN_MODE, fullname);
}
return scoped_fd (result);
/* Open a source file given a symtab S. Returns a file descriptor or
negative number for error.
- This function is a convience function to find_and_open_source. */
+ This function is a convenience function to find_and_open_source. */
scoped_fd
open_source_file (struct symtab *s)
s->fullname = NULL;
scoped_fd fd = find_and_open_source (s->filename, SYMTAB_DIRNAME (s),
&fullname);
+
+ if (fd.get () < 0)
+ {
+ if (SYMTAB_COMPUNIT (s) != nullptr)
+ {
+ const objfile *ofp = COMPUNIT_OBJFILE (SYMTAB_COMPUNIT (s));
+
+ std::string srcpath;
+ if (IS_ABSOLUTE_PATH (s->filename))
+ srcpath = s->filename;
+ else if (SYMTAB_DIRNAME (s) != nullptr)
+ {
+ srcpath = SYMTAB_DIRNAME (s);
+ srcpath += SLASH_STRING;
+ srcpath += s->filename;
+ }
+
+ const struct bfd_build_id *build_id = build_id_bfd_get (ofp->obfd);
+
+ /* Query debuginfod for the source file. */
+ if (build_id != nullptr && !srcpath.empty ())
+ fd = debuginfod_source_query (build_id->data,
+ build_id->size,
+ srcpath.c_str (),
+ &fullname);
+ }
+ }
+
s->fullname = fullname.release ();
return fd;
}
struct ui_out *uiout = current_uiout;
/* Regardless of whether we can open the file, set current_source_symtab. */
- current_source_symtab = s;
- current_source_line = line;
+ current_source_location *loc
+ = get_source_location (current_program_space);
+
+ loc->set (s, line);
first_line_listed = line;
+ last_line_listed = line;
/* If printing of source lines is disabled, just print file and line
number. */
uiout->field_string ("file", symtab_to_filename_for_display (s),
file_name_style.style ());
if (uiout->is_mi_like_p () || !uiout->test_flags (ui_source_list))
- {
+ {
const char *s_fullname = symtab_to_fullname (s);
char *local_fullname;
strcpy (local_fullname, s_fullname);
uiout->field_string ("fullname", local_fullname);
- }
+ }
uiout->text ("\n");
}
}
const char *iter = lines.c_str ();
+ int new_lineno = loc->line ();
while (nlines-- > 0 && *iter != '\0')
{
char buf[20];
- last_line_listed = current_source_line;
+ last_line_listed = loc->line ();
if (flags & PRINT_SOURCE_LINES_FILENAME)
- {
- uiout->text (symtab_to_filename_for_display (s));
- uiout->text (":");
- }
- xsnprintf (buf, sizeof (buf), "%d\t", current_source_line++);
+ {
+ uiout->text (symtab_to_filename_for_display (s));
+ uiout->text (":");
+ }
+ xsnprintf (buf, sizeof (buf), "%d\t", new_lineno++);
uiout->text (buf);
while (*iter != '\0')
if (iter > start)
{
std::string text (start, iter);
- uiout->text (text.c_str ());
+ uiout->text (text);
}
if (*iter == '\r')
{
}
uiout->text ("\n");
}
+
+ loc->set (loc->symtab (), new_lineno);
}
\f
if (arg == 0)
{
- curr_sal.symtab = current_source_symtab;
+ current_source_location *loc
+ = get_source_location (current_program_space);
+ curr_sal.symtab = loc->symtab ();
curr_sal.pspace = current_program_space;
if (last_line_listed != 0)
curr_sal.line = last_line_listed;
else
- curr_sal.line = current_source_line;
+ curr_sal.line = loc->line ();
sals = curr_sal;
}
if (sal.pc != 0)
{
/* This is useful for "info line *0x7f34". If we can't tell the
- user about a source line, at least let them have the symbolic
- address. */
+ user about a source line, at least let them have the symbolic
+ address. */
printf_filtered (" for address ");
wrap_here (" ");
print_address (gdbarch, sal.pc, gdb_stdout);
else if (sal.line > 0
&& find_line_pc_range (sal, &start_pc, &end_pc))
{
- struct gdbarch *gdbarch
- = get_objfile_arch (SYMTAB_OBJFILE (sal.symtab));
+ struct gdbarch *gdbarch = SYMTAB_OBJFILE (sal.symtab)->arch ();
if (start_pc == end_pc)
{
/* If this is the only line, show the source code. If it could
not find the file, don't do anything special. */
- if (sals.size () == 1)
+ if (annotation_level > 0 && sals.size () == 1)
annotate_source_line (sal.symtab, sal.line, 0, start_pc);
}
else
if (msg)
error (("%s"), msg);
- if (current_source_symtab == 0)
+ current_source_location *loc
+ = get_source_location (current_program_space);
+ if (loc->symtab () == nullptr)
select_source_symtab (0);
- scoped_fd desc (open_source_file (current_source_symtab));
+ scoped_fd desc (open_source_file (loc->symtab ()));
if (desc.get () < 0)
- perror_with_name (symtab_to_filename_for_display (current_source_symtab));
+ perror_with_name (symtab_to_filename_for_display (loc->symtab ()));
int line = (forward
? last_line_listed + 1
const std::vector<off_t> *offsets;
if (line < 1
- || !g_source_cache.get_line_charpos (current_source_symtab, &offsets)
+ || !g_source_cache.get_line_charpos (loc->symtab (), &offsets)
|| line > offsets->size ())
error (_("Expression not found"));
if (lseek (desc.get (), (*offsets)[line - 1], 0) < 0)
- perror_with_name (symtab_to_filename_for_display (current_source_symtab));
+ perror_with_name (symtab_to_filename_for_display (loc->symtab ()));
gdb_file_up stream = desc.to_file (FDOPEN_MODE);
clearerr (stream.get ());
while (c != '\n' && (c = fgetc (stream.get ())) >= 0);
/* Remove the \r, if any, at the end of the line, otherwise
- regular expressions that end with $ or \n won't work. */
+ regular expressions that end with $ or \n won't work. */
size_t sz = buf.size ();
if (sz >= 2 && buf[sz - 2] == '\r')
{
if (re_exec (buf.data ()) > 0)
{
/* Match! */
- print_source_lines (current_source_symtab, line, line + 1, 0);
+ print_source_lines (loc->symtab (), line, line + 1, 0);
set_internalvar_integer (lookup_internalvar ("_"), line);
- current_source_line = std::max (line - lines_to_list / 2, 1);
+ loc->set (loc->symtab (), std::max (line - lines_to_list / 2, 1));
return;
}
if (fseek (stream.get (), (*offsets)[line - 1], 0) < 0)
{
const char *filename
- = symtab_to_filename_for_display (current_source_symtab);
+ = symtab_to_filename_for_display (loc->symtab ());
perror_with_name (filename);
}
}
while (rule != NULL)
{
if (FILENAME_CMP (rule->from, from) == 0)
- return rule;
+ return rule;
rule = rule->next;
}
struct substitute_path_rule *prev = substitute_path_rules;
while (prev != NULL && prev->next != rule)
- prev = prev->next;
+ prev = prev->next;
gdb_assert (prev != NULL);
while (rule != NULL)
{
if (from == NULL || substitute_path_rule_matches (rule, from) != 0)
- printf_filtered (" `%s' -> `%s'.\n", rule->from, rule->to);
+ printf_filtered (" `%s' -> `%s'.\n", rule->from, rule->to);
rule = rule->next;
}
}
struct substitute_path_rule *next = rule->next;
if (from == NULL || FILENAME_CMP (from, rule->from) == 0)
- {
- delete_substitute_path_rule (rule);
- rule_found = 1;
- }
+ {
+ delete_substitute_path_rule (rule);
+ rule_found = 1;
+ }
rule = next;
}
}
\f
+void _initialize_source ();
void
-_initialize_source (void)
+_initialize_source ()
{
- struct cmd_list_element *c;
-
- current_source_symtab = 0;
init_source_path ();
/* The intention is to use POSIX Basic Regular Expressions.
just an approximation. */
re_set_syntax (RE_SYNTAX_GREP);
- c = add_cmd ("directory", class_files, directory_command, _("\
+ cmd_list_element *directory_cmd
+ = add_cmd ("directory", class_files, directory_command, _("\
Add directory DIR to beginning of search path for source files.\n\
Forget cached info on source file locations and line positions.\n\
DIR can also be $cwd for the current working directory, or $cdir for the\n\
&cmdlist);
if (dbx_commands)
- add_com_alias ("use", "directory", class_files, 0);
+ add_com_alias ("use", directory_cmd, class_files, 0);
- set_cmd_completer (c, filename_completer);
+ set_cmd_completer (directory_cmd, filename_completer);
add_setshow_optional_filename_cmd ("directories",
class_files,
so that \"x/i\" suffices to start examining the machine code.\n\
The address is also stored as the value of \"$_\"."));
- add_com ("forward-search", class_files, forward_search_command, _("\
+ cmd_list_element *forward_search_cmd
+ = add_com ("forward-search", class_files, forward_search_command, _("\
Search for regular expression (see regex(3)) from last line listed.\n\
The matching line number is also stored as the value of \"$_\"."));
- add_com_alias ("search", "forward-search", class_files, 0);
- add_com_alias ("fo", "forward-search", class_files, 1);
+ add_com_alias ("search", forward_search_cmd, class_files, 0);
+ add_com_alias ("fo", forward_search_cmd, class_files, 1);
- add_com ("reverse-search", class_files, reverse_search_command, _("\
+ cmd_list_element *reverse_search_cmd
+ = add_com ("reverse-search", class_files, reverse_search_command, _("\
Search backward for regular expression (see regex(3)) from last line listed.\n\
The matching line number is also stored as the value of \"$_\"."));
- add_com_alias ("rev", "reverse-search", class_files, 1);
+ add_com_alias ("rev", reverse_search_cmd, class_files, 1);
add_setshow_integer_cmd ("listsize", class_support, &lines_to_list, _("\
Set number of source lines gdb will list by default."), _("\
&setlist, &showlist);
add_cmd ("substitute-path", class_files, set_substitute_path_command,
- _("\
+ _("\
Add a substitution rule to rewrite the source directories.\n\
Usage: set substitute-path FROM TO\n\
The rule is applied only if the directory name starts with FROM\n\
directly followed by a directory separator.\n\
If a substitution rule was previously set for FROM, the old rule\n\
is replaced by the new one."),
- &setlist);
+ &setlist);
add_cmd ("substitute-path", class_files, unset_substitute_path_command,
- _("\
+ _("\
Delete one or all substitution rules rewriting the source directories.\n\
Usage: unset substitute-path [FROM]\n\
Delete the rule for substituting FROM in source directories. If FROM\n\
is not specified, all substituting rules are deleted.\n\
If the debugger cannot find a rule for FROM, it will display a warning."),
- &unsetlist);
+ &unsetlist);
add_cmd ("substitute-path", class_files, show_substitute_path_command,
- _("\
+ _("\
Show one or all substitution rules rewriting the source directories.\n\
Usage: show substitute-path [FROM]\n\
Print the rule for substituting FROM in source directories. If FROM\n\
is not specified, print all substitution rules."),
- &showlist);
+ &showlist);
add_setshow_enum_cmd ("filename-display", class_files,
filename_display_kind_names,
projects / deliverable / binutils-gdb.git / blobdiff