1 /* List lines of source files for GDB, the GNU debugger.
2 Copyright (C) 1986-2022 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "arch-utils.h"
22 #include "expression.h"
29 #include "gdbsupport/filestuff.h"
31 #include <sys/types.h>
34 #include "gdbsupport/gdb_regex.h"
40 #include "filenames.h" /* for DOSish file names */
41 #include "completer.h"
43 #include "readline/tilde.h"
44 #include "gdbsupport/enum-flags.h"
45 #include "gdbsupport/scoped_fd.h"
47 #include "gdbsupport/pathstuff.h"
48 #include "source-cache.h"
49 #include "cli/cli-style.h"
50 #include "observable.h"
52 #include "debuginfod-support.h"
53 #include "gdbsupport/buildargv.h"
55 #define OPEN_MODE (O_RDONLY | O_BINARY)
56 #define FDOPEN_MODE FOPEN_RB
58 /* Path of directories to search for source files.
59 Same format as the PATH environment variable's value. */
61 std::string source_path
;
63 /* Support for source path substitution commands. */
65 struct substitute_path_rule
67 substitute_path_rule (const char *from_
, const char *to_
)
77 static std::list
<substitute_path_rule
> substitute_path_rules
;
79 /* An instance of this is attached to each program space. */
81 struct current_source_location
85 current_source_location () = default;
88 void set (struct symtab
*s
, int l
)
92 gdb::observers::current_source_symtab_and_line_changed
.notify ();
96 struct symtab
*symtab () const
101 /* Get the line number. */
109 /* Symtab of default file for listing lines of. */
111 struct symtab
*m_symtab
= nullptr;
113 /* Default next line to list. */
118 static program_space_key
<current_source_location
> current_source_key
;
120 /* Default number of lines to print with commands like "list".
121 This is based on guessing how many long (i.e. more than chars_per_line
122 characters) lines there will be. To be completely correct, "list"
123 and friends should be rewritten to count characters and see where
124 things are wrapping, but that would be a fair amount of work. */
126 static int lines_to_list
= 10;
128 show_lines_to_list (struct ui_file
*file
, int from_tty
,
129 struct cmd_list_element
*c
, const char *value
)
131 fprintf_filtered (file
,
132 _("Number of source lines gdb "
133 "will list by default is %s.\n"),
137 /* Possible values of 'set filename-display'. */
138 static const char filename_display_basename
[] = "basename";
139 static const char filename_display_relative
[] = "relative";
140 static const char filename_display_absolute
[] = "absolute";
142 static const char *const filename_display_kind_names
[] = {
143 filename_display_basename
,
144 filename_display_relative
,
145 filename_display_absolute
,
149 static const char *filename_display_string
= filename_display_relative
;
152 show_filename_display_string (struct ui_file
*file
, int from_tty
,
153 struct cmd_list_element
*c
, const char *value
)
155 fprintf_filtered (file
, _("Filenames are displayed as \"%s\".\n"), value
);
158 /* When true GDB will stat and open source files as required, but when
159 false, GDB will avoid accessing source files as much as possible. */
161 static bool source_open
= true;
163 /* Implement 'show source open'. */
166 show_source_open (struct ui_file
*file
, int from_tty
,
167 struct cmd_list_element
*c
, const char *value
)
169 fprintf_filtered (file
, _("Source opening is \"%s\".\n"), value
);
172 /* Line number of last line printed. Default for various commands.
173 current_source_line is usually, but not always, the same as this. */
175 static int last_line_listed
;
177 /* First line number listed by last listing command. If 0, then no
178 source lines have yet been listed since the last time the current
179 source line was changed. */
181 static int first_line_listed
;
183 /* Saves the name of the last source file visited and a possible error code.
184 Used to prevent repeating annoying "No such file or directories" msgs. */
186 static struct symtab
*last_source_visited
= NULL
;
187 static bool last_source_error
= false;
189 /* Return the first line listed by print_source_lines.
190 Used by command interpreters to request listing from
194 get_first_line_listed (void)
196 return first_line_listed
;
199 /* Clear line listed range. This makes the next "list" center the
200 printed source lines around the current source line. */
203 clear_lines_listed_range (void)
205 first_line_listed
= 0;
206 last_line_listed
= 0;
209 /* Return the default number of lines to print with commands like the
210 cli "list". The caller of print_source_lines must use this to
211 calculate the end line and use it in the call to print_source_lines
212 as it does not automatically use this value. */
215 get_lines_to_list (void)
217 return lines_to_list
;
220 /* A helper to return the current source location object for PSPACE,
221 creating it if it does not exist. */
223 static current_source_location
*
224 get_source_location (program_space
*pspace
)
226 current_source_location
*loc
227 = current_source_key
.get (pspace
);
229 loc
= current_source_key
.emplace (pspace
);
233 /* Return the current source file for listing and next line to list.
234 NOTE: The returned sal pc and end fields are not valid. */
236 struct symtab_and_line
237 get_current_source_symtab_and_line (void)
239 symtab_and_line cursal
;
240 current_source_location
*loc
= get_source_location (current_program_space
);
242 cursal
.pspace
= current_program_space
;
243 cursal
.symtab
= loc
->symtab ();
244 cursal
.line
= loc
->line ();
251 /* If the current source file for listing is not set, try and get a default.
252 Usually called before get_current_source_symtab_and_line() is called.
253 It may err out if a default cannot be determined.
254 We must be cautious about where it is called, as it can recurse as the
255 process of determining a new default may call the caller!
256 Use get_current_source_symtab_and_line only to get whatever
257 we have without erroring out or trying to get a default. */
260 set_default_source_symtab_and_line (void)
262 if (!have_full_symbols () && !have_partial_symbols ())
263 error (_("No symbol table is loaded. Use the \"file\" command."));
265 /* Pull in a current source symtab if necessary. */
266 current_source_location
*loc
= get_source_location (current_program_space
);
267 if (loc
->symtab () == nullptr)
268 select_source_symtab (0);
271 /* Return the current default file for listing and next line to list
272 (the returned sal pc and end fields are not valid.)
273 and set the current default to whatever is in SAL.
274 NOTE: The returned sal pc and end fields are not valid. */
276 struct symtab_and_line
277 set_current_source_symtab_and_line (const symtab_and_line
&sal
)
279 symtab_and_line cursal
;
281 current_source_location
*loc
= get_source_location (sal
.pspace
);
283 cursal
.pspace
= sal
.pspace
;
284 cursal
.symtab
= loc
->symtab ();
285 cursal
.line
= loc
->line ();
289 loc
->set (sal
.symtab
, sal
.line
);
291 /* Force the next "list" to center around the current line. */
292 clear_lines_listed_range ();
297 /* Reset any information stored about a default file and line to print. */
300 clear_current_source_symtab_and_line (void)
302 current_source_location
*loc
= get_source_location (current_program_space
);
303 loc
->set (nullptr, 0);
309 select_source_symtab (struct symtab
*s
)
313 current_source_location
*loc
314 = get_source_location (SYMTAB_PSPACE (s
));
319 current_source_location
*loc
= get_source_location (current_program_space
);
320 if (loc
->symtab () != nullptr)
323 /* Make the default place to list be the function `main'
325 block_symbol bsym
= lookup_symbol (main_name (), 0, VAR_DOMAIN
, 0);
326 if (bsym
.symbol
!= nullptr && SYMBOL_CLASS (bsym
.symbol
) == LOC_BLOCK
)
328 symtab_and_line sal
= find_function_start_sal (bsym
.symbol
, true);
329 if (sal
.symtab
== NULL
)
330 /* We couldn't find the location of `main', possibly due to missing
331 line number info, fall back to line 1 in the corresponding file. */
332 loc
->set (symbol_symtab (bsym
.symbol
), 1);
334 loc
->set (sal
.symtab
, std::max (sal
.line
- (lines_to_list
- 1), 1));
338 /* Alright; find the last file in the symtab list (ignoring .h's
339 and namespace symtabs). */
341 struct symtab
*new_symtab
= nullptr;
343 for (objfile
*ofp
: current_program_space
->objfiles ())
345 for (compunit_symtab
*cu
: ofp
->compunits ())
347 for (symtab
*symtab
: cu
->filetabs ())
349 const char *name
= symtab
->filename
;
350 int len
= strlen (name
);
352 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
353 || strcmp (name
, "<<C++-namespaces>>") == 0)))
359 loc
->set (new_symtab
, 1);
360 if (new_symtab
!= nullptr)
363 for (objfile
*objfile
: current_program_space
->objfiles ())
365 s
= objfile
->find_last_source_symtab ();
369 if (new_symtab
!= nullptr)
371 loc
->set (new_symtab
,1);
375 error (_("Can't find a default source file"));
378 /* Handler for "set directories path-list" command.
379 "set dir mumble" doesn't prepend paths, it resets the entire
380 path list. The theory is that set(show(dir)) should be a no-op. */
383 set_directories_command (const char *args
,
384 int from_tty
, struct cmd_list_element
*c
)
386 /* This is the value that was set.
387 It needs to be processed to maintain $cdir:$cwd and remove dups. */
388 std::string set_path
= source_path
;
390 /* We preserve the invariant that $cdir:$cwd begins life at the end of
391 the list by calling init_source_path. If they appear earlier in
392 SET_PATH then mod_path will move them appropriately.
393 mod_path will also remove duplicates. */
395 if (!set_path
.empty ())
396 mod_path (set_path
.c_str (), source_path
);
399 /* Print the list of source directories.
400 This is used by the "ld" command, so it has the signature of a command
404 show_directories_1 (ui_file
*file
, char *ignore
, int from_tty
)
406 fputs_filtered ("Source directories searched: ", file
);
407 fputs_filtered (source_path
.c_str (), file
);
408 fputs_filtered ("\n", file
);
411 /* Handler for "show directories" command. */
414 show_directories_command (struct ui_file
*file
, int from_tty
,
415 struct cmd_list_element
*c
, const char *value
)
417 show_directories_1 (file
, NULL
, from_tty
);
423 forget_cached_source_info_for_objfile (struct objfile
*objfile
)
425 for (compunit_symtab
*cu
: objfile
->compunits ())
427 for (symtab
*s
: cu
->filetabs ())
429 if (s
->fullname
!= NULL
)
437 objfile
->forget_cached_source_info ();
443 forget_cached_source_info (void)
445 for (struct program_space
*pspace
: program_spaces
)
446 for (objfile
*objfile
: pspace
->objfiles ())
448 forget_cached_source_info_for_objfile (objfile
);
451 g_source_cache
.clear ();
452 last_source_visited
= NULL
;
456 init_source_path (void)
458 source_path
= string_printf ("$cdir%c$cwd", DIRNAME_SEPARATOR
);
459 forget_cached_source_info ();
462 /* Add zero or more directories to the front of the source path. */
465 directory_command (const char *dirname
, int from_tty
)
467 bool value_changed
= false;
469 /* FIXME, this goes to "delete dir"... */
472 if (!from_tty
|| query (_("Reinitialize source path to empty? ")))
475 value_changed
= true;
480 mod_path (dirname
, source_path
);
481 forget_cached_source_info ();
482 value_changed
= true;
486 gdb::observers::command_param_changed
.notify ("directories",
487 source_path
.c_str ());
489 show_directories_1 (gdb_stdout
, (char *) 0, from_tty
);
493 /* Add a path given with the -d command line switch.
494 This will not be quoted so we must not treat spaces as separators. */
497 directory_switch (const char *dirname
, int from_tty
)
499 add_path (dirname
, source_path
, 0);
502 /* Add zero or more directories to the front of an arbitrary path. */
505 mod_path (const char *dirname
, std::string
&which_path
)
507 add_path (dirname
, which_path
, 1);
510 /* Workhorse of mod_path. Takes an extra argument to determine
511 if dirname should be parsed for separators that indicate multiple
512 directories. This allows for interfaces that pre-parse the dirname
513 and allow specification of traditional separator characters such
517 add_path (const char *dirname
, char **which_path
, int parse_separators
)
519 char *old
= *which_path
;
521 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
;
526 if (parse_separators
)
528 /* This will properly parse the space and tab separators
529 and any quotes that may exist. */
530 gdb_argv
argv (dirname
);
532 for (char *arg
: argv
)
533 dirnames_to_char_ptr_vec_append (&dir_vec
, arg
);
536 dir_vec
.emplace_back (xstrdup (dirname
));
538 for (const gdb::unique_xmalloc_ptr
<char> &name_up
: dir_vec
)
540 char *name
= name_up
.get ();
543 gdb::unique_xmalloc_ptr
<char> new_name_holder
;
545 /* Spaces and tabs will have been removed by buildargv().
546 NAME is the start of the directory.
547 P is the '\0' following the end. */
548 p
= name
+ strlen (name
);
550 while (!(IS_DIR_SEPARATOR (*name
) && p
<= name
+ 1) /* "/" */
551 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
552 /* On MS-DOS and MS-Windows, h:\ is different from h: */
553 && !(p
== name
+ 3 && name
[1] == ':') /* "d:/" */
556 && IS_DIR_SEPARATOR (p
[-1]))
557 /* Sigh. "foo/" => "foo" */
561 while (p
> name
&& p
[-1] == '.')
565 /* "." => getwd (). */
566 name
= current_directory
;
569 else if (p
> name
+ 1 && IS_DIR_SEPARATOR (p
[-2]))
579 /* "...foo/." => "...foo". */
592 new_name_holder
.reset (tilde_expand (name
));
593 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
594 else if (IS_ABSOLUTE_PATH (name
) && p
== name
+ 2) /* "d:" => "d:." */
595 new_name_holder
.reset (concat (name
, ".", (char *) NULL
));
597 else if (!IS_ABSOLUTE_PATH (name
) && name
[0] != '$')
598 new_name_holder
= gdb_abspath (name
);
600 new_name_holder
.reset (savestring (name
, p
- name
));
601 name
= new_name_holder
.get ();
603 /* Unless it's a variable, check existence. */
606 /* These are warnings, not errors, since we don't want a
607 non-existent directory in a .gdbinit file to stop processing
608 of the .gdbinit file.
610 Whether they get added to the path is more debatable. Current
611 answer is yes, in case the user wants to go make the directory
612 or whatever. If the directory continues to not exist/not be
613 a directory/etc, then having them in the path should be
615 if (stat (name
, &st
) < 0)
617 int save_errno
= errno
;
619 fprintf_unfiltered (gdb_stderr
, "Warning: ");
620 print_sys_errmsg (name
, save_errno
);
622 else if ((st
.st_mode
& S_IFMT
) != S_IFDIR
)
623 warning (_("%s is not a directory."), name
);
628 unsigned int len
= strlen (name
);
634 /* FIXME: we should use realpath() or its work-alike
635 before comparing. Then all the code above which
636 removes excess slashes and dots could simply go away. */
637 if (!filename_ncmp (p
, name
, len
)
638 && (p
[len
] == '\0' || p
[len
] == DIRNAME_SEPARATOR
))
640 /* Found it in the search path, remove old copy. */
643 /* Back over leading separator. */
646 if (prefix
> p
- *which_path
)
648 /* Same dir twice in one cmd. */
651 /* Copy from next '\0' or ':'. */
652 memmove (p
, &p
[len
+ 1], strlen (&p
[len
+ 1]) + 1);
654 p
= strchr (p
, DIRNAME_SEPARATOR
);
661 tinybuf
[0] = DIRNAME_SEPARATOR
;
664 /* If we have already tacked on a name(s) in this command,
665 be sure they stay on the front as we tack on some
669 std::string temp
= std::string (old
, prefix
) + tinybuf
+ name
;
670 *which_path
= concat (temp
.c_str (), &old
[prefix
],
672 prefix
= temp
.length ();
676 *which_path
= concat (name
, (old
[0] ? tinybuf
: old
),
678 prefix
= strlen (name
);
688 /* add_path would need to be re-written to work on an std::string, but this is
689 not trivial. Hence this overload which copies to a `char *` and back. */
692 add_path (const char *dirname
, std::string
&which_path
, int parse_separators
)
694 char *which_path_copy
= xstrdup (which_path
.data ());
695 add_path (dirname
, &which_path_copy
, parse_separators
);
696 which_path
= which_path_copy
;
697 xfree (which_path_copy
);
701 info_source_command (const char *ignore
, int from_tty
)
703 current_source_location
*loc
704 = get_source_location (current_program_space
);
705 struct symtab
*s
= loc
->symtab ();
706 struct compunit_symtab
*cust
;
710 printf_filtered (_("No current source file.\n"));
714 cust
= SYMTAB_COMPUNIT (s
);
715 printf_filtered (_("Current source file is %s\n"), s
->filename
);
716 if (SYMTAB_DIRNAME (s
) != NULL
)
717 printf_filtered (_("Compilation directory is %s\n"), SYMTAB_DIRNAME (s
));
719 printf_filtered (_("Located in %s\n"), s
->fullname
);
720 const std::vector
<off_t
> *offsets
;
721 if (g_source_cache
.get_line_charpos (s
, &offsets
))
722 printf_filtered (_("Contains %d line%s.\n"), (int) offsets
->size (),
723 offsets
->size () == 1 ? "" : "s");
725 printf_filtered (_("Source language is %s.\n"), language_str (s
->language
));
726 printf_filtered (_("Producer is %s.\n"),
727 COMPUNIT_PRODUCER (cust
) != NULL
728 ? COMPUNIT_PRODUCER (cust
) : _("unknown"));
729 printf_filtered (_("Compiled with %s debugging format.\n"),
730 cust
->debugformat ());
731 printf_filtered (_("%s preprocessor macro info.\n"),
732 COMPUNIT_MACRO_TABLE (cust
) != NULL
733 ? "Includes" : "Does not include");
737 /* Helper function to remove characters from the start of PATH so that
738 PATH can then be appended to a directory name. We remove leading drive
739 letters (for dos) as well as leading '/' characters and './'
743 prepare_path_for_appending (const char *path
)
745 /* For dos paths, d:/foo -> /foo, and d:foo -> foo. */
746 if (HAS_DRIVE_SPEC (path
))
747 path
= STRIP_DRIVE_SPEC (path
);
749 const char *old_path
;
754 /* /foo => foo, to avoid multiple slashes that Emacs doesn't like. */
755 while (IS_DIR_SEPARATOR(path
[0]))
759 while (path
[0] == '.' && IS_DIR_SEPARATOR (path
[1]))
762 while (old_path
!= path
);
767 /* Open a file named STRING, searching path PATH (dir names sep by some char)
768 using mode MODE in the calls to open. You cannot use this function to
769 create files (O_CREAT).
771 OPTS specifies the function behaviour in specific cases.
773 If OPF_TRY_CWD_FIRST, try to open ./STRING before searching PATH.
774 (ie pretend the first element of PATH is "."). This also indicates
775 that, unless OPF_SEARCH_IN_PATH is also specified, a slash in STRING
776 disables searching of the path (this is so that "exec-file ./foo" or
777 "symbol-file ./foo" insures that you get that particular version of
778 foo or an error message).
780 If OPTS has OPF_SEARCH_IN_PATH set, absolute names will also be
781 searched in path (we usually want this for source files but not for
784 If FILENAME_OPENED is non-null, set it to a newly allocated string naming
785 the actual file opened (this string will always start with a "/"). We
786 have to take special pains to avoid doubling the "/" between the directory
787 and the file, sigh! Emacs gets confuzzed by this when we print the
790 If OPTS has OPF_RETURN_REALPATH set return FILENAME_OPENED resolved by
791 gdb_realpath. Even without OPF_RETURN_REALPATH this function still returns
792 filename starting with "/". If FILENAME_OPENED is NULL this option has no
795 If a file is found, return the descriptor.
796 Otherwise, return -1, with errno set for the last name we tried to open. */
798 /* >>>> This should only allow files of certain types,
799 >>>> eg executable, non-directory. */
801 openp (const char *path
, openp_flags opts
, const char *string
,
802 int mode
, gdb::unique_xmalloc_ptr
<char> *filename_opened
)
807 /* The errno set for the last name we tried to open (and
810 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
;
812 /* The open syscall MODE parameter is not specified. */
813 gdb_assert ((mode
& O_CREAT
) == 0);
814 gdb_assert (string
!= NULL
);
816 /* A file with an empty name cannot possibly exist. Report a failure
817 without further checking.
819 This is an optimization which also defends us against buggy
820 implementations of the "stat" function. For instance, we have
821 noticed that a MinGW debugger built on Windows XP 32bits crashes
822 when the debugger is started with an empty argument. */
823 if (string
[0] == '\0')
834 if ((opts
& OPF_TRY_CWD_FIRST
) || IS_ABSOLUTE_PATH (string
))
836 int i
, reg_file_errno
;
838 if (is_regular_file (string
, ®_file_errno
))
840 filename
= (char *) alloca (strlen (string
) + 1);
841 strcpy (filename
, string
);
842 fd
= gdb_open_cloexec (filename
, mode
, 0).release ();
851 last_errno
= reg_file_errno
;
854 if (!(opts
& OPF_SEARCH_IN_PATH
))
855 for (i
= 0; string
[i
]; i
++)
856 if (IS_DIR_SEPARATOR (string
[i
]))
860 /* Remove characters from the start of PATH that we don't need when PATH
861 is appended to a directory name. */
862 string
= prepare_path_for_appending (string
);
864 alloclen
= strlen (path
) + strlen (string
) + 2;
865 filename
= (char *) alloca (alloclen
);
869 dir_vec
= dirnames_to_char_ptr_vec (path
);
871 for (const gdb::unique_xmalloc_ptr
<char> &dir_up
: dir_vec
)
873 char *dir
= dir_up
.get ();
874 size_t len
= strlen (dir
);
877 if (strcmp (dir
, "$cwd") == 0)
879 /* Name is $cwd -- insert current directory name instead. */
882 /* First, realloc the filename buffer if too short. */
883 len
= strlen (current_directory
);
884 newlen
= len
+ strlen (string
) + 2;
885 if (newlen
> alloclen
)
888 filename
= (char *) alloca (alloclen
);
890 strcpy (filename
, current_directory
);
892 else if (strchr(dir
, '~'))
894 /* See whether we need to expand the tilde. */
897 gdb::unique_xmalloc_ptr
<char> tilde_expanded (tilde_expand (dir
));
899 /* First, realloc the filename buffer if too short. */
900 len
= strlen (tilde_expanded
.get ());
901 newlen
= len
+ strlen (string
) + 2;
902 if (newlen
> alloclen
)
905 filename
= (char *) alloca (alloclen
);
907 strcpy (filename
, tilde_expanded
.get ());
911 /* Normal file name in path -- just use it. */
912 strcpy (filename
, dir
);
914 /* Don't search $cdir. It's also a magic path like $cwd, but we
915 don't have enough information to expand it. The user *could*
916 have an actual directory named '$cdir' but handling that would
917 be confusing, it would mean different things in different
918 contexts. If the user really has '$cdir' one can use './$cdir'.
919 We can get $cdir when loading scripts. When loading source files
920 $cdir must have already been expanded to the correct value. */
921 if (strcmp (dir
, "$cdir") == 0)
925 /* Remove trailing slashes. */
926 while (len
> 0 && IS_DIR_SEPARATOR (filename
[len
- 1]))
929 strcat (filename
+ len
, SLASH_STRING
);
930 strcat (filename
, string
);
932 if (is_regular_file (filename
, ®_file_errno
))
934 fd
= gdb_open_cloexec (filename
, mode
, 0).release ();
940 last_errno
= reg_file_errno
;
946 /* If a file was opened, canonicalize its filename. */
948 filename_opened
->reset (NULL
);
949 else if ((opts
& OPF_RETURN_REALPATH
) != 0)
950 *filename_opened
= gdb_realpath (filename
);
952 *filename_opened
= gdb_abspath (filename
);
960 /* This is essentially a convenience, for clients that want the behaviour
961 of openp, using source_path, but that really don't want the file to be
962 opened but want instead just to know what the full pathname is (as
963 qualified against source_path).
965 The current working directory is searched first.
967 If the file was found, this function returns 1, and FULL_PATHNAME is
968 set to the fully-qualified pathname.
970 Else, this functions returns 0, and FULL_PATHNAME is set to NULL. */
972 source_full_path_of (const char *filename
,
973 gdb::unique_xmalloc_ptr
<char> *full_pathname
)
977 fd
= openp (source_path
.c_str (),
978 OPF_TRY_CWD_FIRST
| OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
,
979 filename
, O_RDONLY
, full_pathname
);
982 full_pathname
->reset (NULL
);
990 /* Return non-zero if RULE matches PATH, that is if the rule can be
994 substitute_path_rule_matches (const struct substitute_path_rule
*rule
,
997 const int from_len
= rule
->from
.length ();
998 const int path_len
= strlen (path
);
1000 if (path_len
< from_len
)
1003 /* The substitution rules are anchored at the start of the path,
1004 so the path should start with rule->from. */
1006 if (filename_ncmp (path
, rule
->from
.c_str (), from_len
) != 0)
1009 /* Make sure that the region in the path that matches the substitution
1010 rule is immediately followed by a directory separator (or the end of
1011 string character). */
1013 if (path
[from_len
] != '\0' && !IS_DIR_SEPARATOR (path
[from_len
]))
1019 /* Find the substitute-path rule that applies to PATH and return it.
1020 Return NULL if no rule applies. */
1022 static struct substitute_path_rule
*
1023 get_substitute_path_rule (const char *path
)
1025 for (substitute_path_rule
&rule
: substitute_path_rules
)
1026 if (substitute_path_rule_matches (&rule
, path
))
1032 /* If the user specified a source path substitution rule that applies
1033 to PATH, then apply it and return the new path.
1035 Return NULL if no substitution rule was specified by the user,
1036 or if no rule applied to the given PATH. */
1038 gdb::unique_xmalloc_ptr
<char>
1039 rewrite_source_path (const char *path
)
1041 const struct substitute_path_rule
*rule
= get_substitute_path_rule (path
);
1043 if (rule
== nullptr)
1046 /* Compute the rewritten path and return it. */
1048 return (gdb::unique_xmalloc_ptr
<char>
1049 (concat (rule
->to
.c_str (), path
+ rule
->from
.length (), nullptr)));
1055 find_and_open_source (const char *filename
,
1056 const char *dirname
,
1057 gdb::unique_xmalloc_ptr
<char> *fullname
)
1059 const char *path
= source_path
.c_str ();
1060 std::string expanded_path_holder
;
1063 /* If reading of source files is disabled then return a result indicating
1064 the attempt to read this source file failed. GDB will then display
1065 the filename and line number instead. */
1067 return scoped_fd (-1);
1069 /* Quick way out if we already know its full name. */
1072 /* The user may have requested that source paths be rewritten
1073 according to substitution rules he provided. If a substitution
1074 rule applies to this path, then apply it. */
1075 gdb::unique_xmalloc_ptr
<char> rewritten_fullname
1076 = rewrite_source_path (fullname
->get ());
1078 if (rewritten_fullname
!= NULL
)
1079 *fullname
= std::move (rewritten_fullname
);
1081 scoped_fd result
= gdb_open_cloexec (fullname
->get (), OPEN_MODE
, 0);
1082 if (result
.get () >= 0)
1084 *fullname
= gdb_realpath (fullname
->get ());
1088 /* Didn't work -- free old one, try again. */
1089 fullname
->reset (NULL
);
1092 gdb::unique_xmalloc_ptr
<char> rewritten_dirname
;
1093 if (dirname
!= NULL
)
1095 /* If necessary, rewrite the compilation directory name according
1096 to the source path substitution rules specified by the user. */
1098 rewritten_dirname
= rewrite_source_path (dirname
);
1100 if (rewritten_dirname
!= NULL
)
1101 dirname
= rewritten_dirname
.get ();
1103 /* Replace a path entry of $cdir with the compilation directory
1106 p
= strstr (source_path
.c_str (), "$cdir");
1107 if (p
&& (p
== path
|| p
[-1] == DIRNAME_SEPARATOR
)
1108 && (p
[cdir_len
] == DIRNAME_SEPARATOR
|| p
[cdir_len
] == '\0'))
1110 int len
= p
- source_path
.c_str ();
1113 expanded_path_holder
= source_path
.substr (0, len
);
1116 expanded_path_holder
+= dirname
;
1119 expanded_path_holder
+= source_path
.c_str () + len
+ cdir_len
;
1121 path
= expanded_path_holder
.c_str ();
1125 gdb::unique_xmalloc_ptr
<char> rewritten_filename
1126 = rewrite_source_path (filename
);
1128 if (rewritten_filename
!= NULL
)
1129 filename
= rewritten_filename
.get ();
1131 /* Try to locate file using filename. */
1132 int result
= openp (path
, OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
, filename
,
1133 OPEN_MODE
, fullname
);
1134 if (result
< 0 && dirname
!= NULL
)
1136 /* Remove characters from the start of PATH that we don't need when
1137 PATH is appended to a directory name. */
1138 const char *filename_start
= prepare_path_for_appending (filename
);
1140 /* Try to locate file using compilation dir + filename. This is
1141 helpful if part of the compilation directory was removed,
1142 e.g. using gcc's -fdebug-prefix-map, and we have added the missing
1143 prefix to source_path. */
1144 std::string
cdir_filename (dirname
);
1146 /* Remove any trailing directory separators. */
1147 while (IS_DIR_SEPARATOR (cdir_filename
.back ()))
1148 cdir_filename
.pop_back ();
1150 /* Add our own directory separator. */
1151 cdir_filename
.append (SLASH_STRING
);
1152 cdir_filename
.append (filename_start
);
1154 result
= openp (path
, OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
,
1155 cdir_filename
.c_str (), OPEN_MODE
, fullname
);
1159 /* Didn't work. Try using just the basename. */
1160 p
= lbasename (filename
);
1162 result
= openp (path
, OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
, p
,
1163 OPEN_MODE
, fullname
);
1166 return scoped_fd (result
);
1169 /* Open a source file given a symtab S. Returns a file descriptor or
1170 negative number for error.
1172 This function is a convenience function to find_and_open_source. */
1175 open_source_file (struct symtab
*s
)
1178 return scoped_fd (-1);
1180 gdb::unique_xmalloc_ptr
<char> fullname (s
->fullname
);
1182 scoped_fd fd
= find_and_open_source (s
->filename
, SYMTAB_DIRNAME (s
),
1187 if (SYMTAB_COMPUNIT (s
) != nullptr)
1189 const objfile
*ofp
= SYMTAB_COMPUNIT (s
)->objfile ();
1191 std::string srcpath
;
1192 if (IS_ABSOLUTE_PATH (s
->filename
))
1193 srcpath
= s
->filename
;
1194 else if (SYMTAB_DIRNAME (s
) != nullptr)
1196 srcpath
= SYMTAB_DIRNAME (s
);
1197 srcpath
+= SLASH_STRING
;
1198 srcpath
+= s
->filename
;
1201 const struct bfd_build_id
*build_id
= build_id_bfd_get (ofp
->obfd
);
1203 /* Query debuginfod for the source file. */
1204 if (build_id
!= nullptr && !srcpath
.empty ())
1205 fd
= debuginfod_source_query (build_id
->data
,
1212 s
->fullname
= fullname
.release ();
1218 gdb::unique_xmalloc_ptr
<char>
1219 find_source_or_rewrite (const char *filename
, const char *dirname
)
1221 gdb::unique_xmalloc_ptr
<char> fullname
;
1223 scoped_fd fd
= find_and_open_source (filename
, dirname
, &fullname
);
1226 /* rewrite_source_path would be applied by find_and_open_source, we
1227 should report the pathname where GDB tried to find the file. */
1229 if (dirname
== nullptr || IS_ABSOLUTE_PATH (filename
))
1230 fullname
.reset (xstrdup (filename
));
1232 fullname
.reset (concat (dirname
, SLASH_STRING
,
1233 filename
, (char *) nullptr));
1235 gdb::unique_xmalloc_ptr
<char> rewritten
1236 = rewrite_source_path (fullname
.get ());
1237 if (rewritten
!= nullptr)
1238 fullname
= std::move (rewritten
);
1244 /* Finds the fullname that a symtab represents.
1246 This functions finds the fullname and saves it in s->fullname.
1247 It will also return the value.
1249 If this function fails to find the file that this symtab represents,
1250 the expected fullname is used. Therefore the files does not have to
1254 symtab_to_fullname (struct symtab
*s
)
1256 /* Use cached copy if we have it.
1257 We rely on forget_cached_source_info being called appropriately
1258 to handle cases like the file being moved. */
1259 if (s
->fullname
== NULL
)
1261 scoped_fd fd
= open_source_file (s
);
1265 gdb::unique_xmalloc_ptr
<char> fullname
;
1267 /* rewrite_source_path would be applied by find_and_open_source, we
1268 should report the pathname where GDB tried to find the file. */
1270 if (SYMTAB_DIRNAME (s
) == NULL
|| IS_ABSOLUTE_PATH (s
->filename
))
1271 fullname
.reset (xstrdup (s
->filename
));
1273 fullname
.reset (concat (SYMTAB_DIRNAME (s
), SLASH_STRING
,
1274 s
->filename
, (char *) NULL
));
1276 s
->fullname
= rewrite_source_path (fullname
.get ()).release ();
1277 if (s
->fullname
== NULL
)
1278 s
->fullname
= fullname
.release ();
1285 /* See commentary in source.h. */
1288 symtab_to_filename_for_display (struct symtab
*symtab
)
1290 if (filename_display_string
== filename_display_basename
)
1291 return lbasename (symtab
->filename
);
1292 else if (filename_display_string
== filename_display_absolute
)
1293 return symtab_to_fullname (symtab
);
1294 else if (filename_display_string
== filename_display_relative
)
1295 return symtab
->filename
;
1297 internal_error (__FILE__
, __LINE__
, _("invalid filename_display_string"));
1302 /* Print source lines from the file of symtab S,
1303 starting with line number LINE and stopping before line number STOPLINE. */
1306 print_source_lines_base (struct symtab
*s
, int line
, int stopline
,
1307 print_source_lines_flags flags
)
1309 bool noprint
= false;
1310 int nlines
= stopline
- line
;
1311 struct ui_out
*uiout
= current_uiout
;
1313 /* Regardless of whether we can open the file, set current_source_symtab. */
1314 current_source_location
*loc
1315 = get_source_location (current_program_space
);
1318 first_line_listed
= line
;
1319 last_line_listed
= line
;
1321 /* If printing of source lines is disabled, just print file and line
1323 if (uiout
->test_flags (ui_source_list
) && source_open
)
1325 /* Only prints "No such file or directory" once. */
1326 if (s
== last_source_visited
)
1328 if (last_source_error
)
1330 flags
|= PRINT_SOURCE_LINES_NOERROR
;
1336 last_source_visited
= s
;
1337 scoped_fd desc
= open_source_file (s
);
1338 last_source_error
= desc
.get () < 0;
1339 if (last_source_error
)
1345 flags
|= PRINT_SOURCE_LINES_NOERROR
;
1351 if (!(flags
& PRINT_SOURCE_LINES_NOERROR
))
1353 const char *filename
= symtab_to_filename_for_display (s
);
1354 int len
= strlen (filename
) + 100;
1355 char *name
= (char *) alloca (len
);
1357 xsnprintf (name
, len
, "%d\t%s", line
, filename
);
1358 print_sys_errmsg (name
, errno
);
1362 uiout
->field_signed ("line", line
);
1363 uiout
->text ("\tin ");
1365 /* CLI expects only the "file" field. TUI expects only the
1366 "fullname" field (and TUI does break if "file" is printed).
1367 MI expects both fields. ui_source_list is set only for CLI,
1369 if (uiout
->is_mi_like_p () || uiout
->test_flags (ui_source_list
))
1370 uiout
->field_string ("file", symtab_to_filename_for_display (s
),
1371 file_name_style
.style ());
1372 if (uiout
->is_mi_like_p () || !uiout
->test_flags (ui_source_list
))
1374 const char *s_fullname
= symtab_to_fullname (s
);
1375 char *local_fullname
;
1377 /* ui_out_field_string may free S_FULLNAME by calling
1378 open_source_file for it again. See e.g.,
1379 tui_field_string->tui_show_source. */
1380 local_fullname
= (char *) alloca (strlen (s_fullname
) + 1);
1381 strcpy (local_fullname
, s_fullname
);
1383 uiout
->field_string ("fullname", local_fullname
);
1392 /* If the user requested a sequence of lines that seems to go backward
1393 (from high to low line numbers) then we don't print anything. */
1394 if (stopline
<= line
)
1398 if (!g_source_cache
.get_source_lines (s
, line
, stopline
- 1, &lines
))
1400 const std::vector
<off_t
> *offsets
= nullptr;
1401 g_source_cache
.get_line_charpos (s
, &offsets
);
1402 error (_("Line number %d out of range; %s has %d lines."),
1403 line
, symtab_to_filename_for_display (s
),
1404 offsets
== nullptr ? 0 : (int) offsets
->size ());
1407 const char *iter
= lines
.c_str ();
1408 int new_lineno
= loc
->line ();
1409 while (nlines
-- > 0 && *iter
!= '\0')
1413 last_line_listed
= loc
->line ();
1414 if (flags
& PRINT_SOURCE_LINES_FILENAME
)
1416 uiout
->text (symtab_to_filename_for_display (s
));
1419 xsnprintf (buf
, sizeof (buf
), "%d\t", new_lineno
++);
1422 while (*iter
!= '\0')
1424 /* Find a run of characters that can be emitted at once.
1425 This is done so that escape sequences are kept
1427 const char *start
= iter
;
1433 if (c
== '\033' && skip_ansi_escape (iter
, &skip_bytes
))
1435 else if (c
>= 0 && c
< 040 && c
!= '\t')
1444 std::string
text (start
, iter
);
1449 /* Treat either \r or \r\n as a single newline. */
1455 else if (*iter
== '\n')
1460 else if (*iter
> 0 && *iter
< 040)
1462 xsnprintf (buf
, sizeof (buf
), "^%c", *iter
+ 0100);
1466 else if (*iter
== 0177)
1475 loc
->set (loc
->symtab (), new_lineno
);
1482 print_source_lines (struct symtab
*s
, int line
, int stopline
,
1483 print_source_lines_flags flags
)
1485 print_source_lines_base (s
, line
, stopline
, flags
);
1491 print_source_lines (struct symtab
*s
, source_lines_range line_range
,
1492 print_source_lines_flags flags
)
1494 print_source_lines_base (s
, line_range
.startline (),
1495 line_range
.stopline (), flags
);
1500 /* Print info on range of pc's in a specified line. */
1503 info_line_command (const char *arg
, int from_tty
)
1505 CORE_ADDR start_pc
, end_pc
;
1507 std::vector
<symtab_and_line
> decoded_sals
;
1508 symtab_and_line curr_sal
;
1509 gdb::array_view
<symtab_and_line
> sals
;
1513 current_source_location
*loc
1514 = get_source_location (current_program_space
);
1515 curr_sal
.symtab
= loc
->symtab ();
1516 curr_sal
.pspace
= current_program_space
;
1517 if (last_line_listed
!= 0)
1518 curr_sal
.line
= last_line_listed
;
1520 curr_sal
.line
= loc
->line ();
1526 decoded_sals
= decode_line_with_last_displayed (arg
,
1527 DECODE_LINE_LIST_MODE
);
1528 sals
= decoded_sals
;
1533 /* C++ More than one line may have been specified, as when the user
1534 specifies an overloaded function name. Print info on them all. */
1535 for (const auto &sal
: sals
)
1537 if (sal
.pspace
!= current_program_space
)
1540 if (sal
.symtab
== 0)
1542 struct gdbarch
*gdbarch
= get_current_arch ();
1544 printf_filtered (_("No line number information available"));
1547 /* This is useful for "info line *0x7f34". If we can't tell the
1548 user about a source line, at least let them have the symbolic
1550 printf_filtered (" for address ");
1551 gdb_stdout
->wrap_here (2);
1552 print_address (gdbarch
, sal
.pc
, gdb_stdout
);
1555 printf_filtered (".");
1556 printf_filtered ("\n");
1558 else if (sal
.line
> 0
1559 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
1561 struct gdbarch
*gdbarch
= SYMTAB_OBJFILE (sal
.symtab
)->arch ();
1563 if (start_pc
== end_pc
)
1565 printf_filtered ("Line %d of \"%s\"",
1567 symtab_to_filename_for_display (sal
.symtab
));
1568 gdb_stdout
->wrap_here (2);
1569 printf_filtered (" is at address ");
1570 print_address (gdbarch
, start_pc
, gdb_stdout
);
1571 gdb_stdout
->wrap_here (2);
1572 printf_filtered (" but contains no code.\n");
1576 printf_filtered ("Line %d of \"%s\"",
1578 symtab_to_filename_for_display (sal
.symtab
));
1579 gdb_stdout
->wrap_here (2);
1580 printf_filtered (" starts at address ");
1581 print_address (gdbarch
, start_pc
, gdb_stdout
);
1582 gdb_stdout
->wrap_here (2);
1583 printf_filtered (" and ends at ");
1584 print_address (gdbarch
, end_pc
, gdb_stdout
);
1585 printf_filtered (".\n");
1588 /* x/i should display this line's code. */
1589 set_next_address (gdbarch
, start_pc
);
1591 /* Repeating "info line" should do the following line. */
1592 last_line_listed
= sal
.line
+ 1;
1594 /* If this is the only line, show the source code. If it could
1595 not find the file, don't do anything special. */
1596 if (annotation_level
> 0 && sals
.size () == 1)
1597 annotate_source_line (sal
.symtab
, sal
.line
, 0, start_pc
);
1600 /* Is there any case in which we get here, and have an address
1601 which the user would want to see? If we have debugging symbols
1602 and no line numbers? */
1603 printf_filtered (_("Line number %d is out of range for \"%s\".\n"),
1604 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
1608 /* Commands to search the source file for a regexp. */
1610 /* Helper for forward_search_command/reverse_search_command. FORWARD
1611 indicates direction: true for forward, false for
1612 backward/reverse. */
1615 search_command_helper (const char *regex
, int from_tty
, bool forward
)
1617 const char *msg
= re_comp (regex
);
1619 error (("%s"), msg
);
1621 current_source_location
*loc
1622 = get_source_location (current_program_space
);
1623 if (loc
->symtab () == nullptr)
1624 select_source_symtab (0);
1627 error (_("source code access disabled"));
1629 scoped_fd
desc (open_source_file (loc
->symtab ()));
1630 if (desc
.get () < 0)
1631 perror_with_name (symtab_to_filename_for_display (loc
->symtab ()));
1634 ? last_line_listed
+ 1
1635 : last_line_listed
- 1);
1637 const std::vector
<off_t
> *offsets
;
1639 || !g_source_cache
.get_line_charpos (loc
->symtab (), &offsets
)
1640 || line
> offsets
->size ())
1641 error (_("Expression not found"));
1643 if (lseek (desc
.get (), (*offsets
)[line
- 1], 0) < 0)
1644 perror_with_name (symtab_to_filename_for_display (loc
->symtab ()));
1646 gdb_file_up stream
= desc
.to_file (FDOPEN_MODE
);
1647 clearerr (stream
.get ());
1649 gdb::def_vector
<char> buf
;
1656 int c
= fgetc (stream
.get ());
1663 while (c
!= '\n' && (c
= fgetc (stream
.get ())) >= 0);
1665 /* Remove the \r, if any, at the end of the line, otherwise
1666 regular expressions that end with $ or \n won't work. */
1667 size_t sz
= buf
.size ();
1668 if (sz
>= 2 && buf
[sz
- 2] == '\r')
1671 buf
.resize (sz
- 1);
1674 /* We now have a source line in buf, null terminate and match. */
1675 buf
.push_back ('\0');
1676 if (re_exec (buf
.data ()) > 0)
1679 print_source_lines (loc
->symtab (), line
, line
+ 1, 0);
1680 set_internalvar_integer (lookup_internalvar ("_"), line
);
1681 loc
->set (loc
->symtab (), std::max (line
- lines_to_list
/ 2, 1));
1692 if (fseek (stream
.get (), (*offsets
)[line
- 1], 0) < 0)
1694 const char *filename
1695 = symtab_to_filename_for_display (loc
->symtab ());
1696 perror_with_name (filename
);
1701 printf_filtered (_("Expression not found\n"));
1705 forward_search_command (const char *regex
, int from_tty
)
1707 search_command_helper (regex
, from_tty
, true);
1711 reverse_search_command (const char *regex
, int from_tty
)
1713 search_command_helper (regex
, from_tty
, false);
1716 /* If the last character of PATH is a directory separator, then strip it. */
1719 strip_trailing_directory_separator (char *path
)
1721 const int last
= strlen (path
) - 1;
1724 return; /* No stripping is needed if PATH is the empty string. */
1726 if (IS_DIR_SEPARATOR (path
[last
]))
1730 /* Add a new substitute-path rule at the end of the current list of rules.
1731 The new rule will replace FROM into TO. */
1734 add_substitute_path_rule (const char *from
, const char *to
)
1736 substitute_path_rules
.emplace_back (from
, to
);
1739 /* Implement the "show substitute-path" command. */
1742 show_substitute_path_command (const char *args
, int from_tty
)
1746 gdb_argv
argv (args
);
1748 /* We expect zero or one argument. */
1750 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1751 error (_("Too many arguments in command"));
1753 if (argv
!= NULL
&& argv
[0] != NULL
)
1756 /* Print the substitution rules. */
1760 (_("Source path substitution rule matching `%s':\n"), from
);
1762 printf_filtered (_("List of all source path substitution rules:\n"));
1764 for (substitute_path_rule
&rule
: substitute_path_rules
)
1766 if (from
== NULL
|| substitute_path_rule_matches (&rule
, from
) != 0)
1767 printf_filtered (" `%s' -> `%s'.\n", rule
.from
.c_str (),
1772 /* Implement the "unset substitute-path" command. */
1775 unset_substitute_path_command (const char *args
, int from_tty
)
1777 gdb_argv
argv (args
);
1780 /* This function takes either 0 or 1 argument. */
1782 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1783 error (_("Incorrect usage, too many arguments in command"));
1785 if (argv
!= NULL
&& argv
[0] != NULL
)
1788 /* If the user asked for all the rules to be deleted, ask him
1789 to confirm and give him a chance to abort before the action
1793 && !query (_("Delete all source path substitution rules? ")))
1794 error (_("Canceled"));
1796 /* Delete the rule matching the argument. No argument means that
1797 all rules should be deleted. */
1799 if (from
== nullptr)
1800 substitute_path_rules
.clear ();
1804 = std::remove_if (substitute_path_rules
.begin (),
1805 substitute_path_rules
.end (),
1806 [&] (const substitute_path_rule
&rule
)
1808 return FILENAME_CMP (from
,
1809 rule
.from
.c_str ()) == 0;
1811 bool rule_found
= iter
!= substitute_path_rules
.end ();
1812 substitute_path_rules
.erase (iter
, substitute_path_rules
.end ());
1814 /* If the user asked for a specific rule to be deleted but
1815 we could not find it, then report an error. */
1818 error (_("No substitution rule defined for `%s'"), from
);
1821 forget_cached_source_info ();
1824 /* Add a new source path substitution rule. */
1827 set_substitute_path_command (const char *args
, int from_tty
)
1829 gdb_argv
argv (args
);
1831 if (argv
== NULL
|| argv
[0] == NULL
|| argv
[1] == NULL
)
1832 error (_("Incorrect usage, too few arguments in command"));
1834 if (argv
[2] != NULL
)
1835 error (_("Incorrect usage, too many arguments in command"));
1837 if (*(argv
[0]) == '\0')
1838 error (_("First argument must be at least one character long"));
1840 /* Strip any trailing directory separator character in either FROM
1841 or TO. The substitution rule already implicitly contains them. */
1842 strip_trailing_directory_separator (argv
[0]);
1843 strip_trailing_directory_separator (argv
[1]);
1845 /* If a rule with the same "from" was previously defined, then
1846 delete it. This new rule replaces it. */
1849 = std::remove_if (substitute_path_rules
.begin (),
1850 substitute_path_rules
.end (),
1851 [&] (const substitute_path_rule
&rule
)
1853 return FILENAME_CMP (argv
[0], rule
.from
.c_str ()) == 0;
1855 substitute_path_rules
.erase (iter
, substitute_path_rules
.end ());
1857 /* Insert the new substitution rule. */
1859 add_substitute_path_rule (argv
[0], argv
[1]);
1860 forget_cached_source_info ();
1865 source_lines_range::source_lines_range (int startline
,
1866 source_lines_range::direction dir
)
1868 if (dir
== source_lines_range::FORWARD
)
1870 LONGEST end
= static_cast <LONGEST
> (startline
) + get_lines_to_list ();
1875 m_startline
= startline
;
1876 m_stopline
= static_cast <int> (end
);
1880 LONGEST start
= static_cast <LONGEST
> (startline
) - get_lines_to_list ();
1885 m_startline
= static_cast <int> (start
);
1886 m_stopline
= startline
;
1890 /* Handle the "set source" base command. */
1893 set_source (const char *arg
, int from_tty
)
1895 help_list (setsourcelist
, "set source ", all_commands
, gdb_stdout
);
1898 /* Handle the "show source" base command. */
1901 show_source (const char *args
, int from_tty
)
1903 help_list (showsourcelist
, "show source ", all_commands
, gdb_stdout
);
1907 void _initialize_source ();
1909 _initialize_source ()
1911 init_source_path ();
1913 /* The intention is to use POSIX Basic Regular Expressions.
1914 Always use the GNU regex routine for consistency across all hosts.
1915 Our current GNU regex.c does not have all the POSIX features, so this is
1916 just an approximation. */
1917 re_set_syntax (RE_SYNTAX_GREP
);
1919 cmd_list_element
*directory_cmd
1920 = add_cmd ("directory", class_files
, directory_command
, _("\
1921 Add directory DIR to beginning of search path for source files.\n\
1922 Forget cached info on source file locations and line positions.\n\
1923 DIR can also be $cwd for the current working directory, or $cdir for the\n\
1924 directory in which the source file was compiled into object code.\n\
1925 With no argument, reset the search path to $cdir:$cwd, the default."),
1929 add_com_alias ("use", directory_cmd
, class_files
, 0);
1931 set_cmd_completer (directory_cmd
, filename_completer
);
1933 add_setshow_optional_filename_cmd ("directories",
1937 Set the search path for finding source files."),
1939 Show the search path for finding source files."),
1941 $cwd in the path means the current working directory.\n\
1942 $cdir in the path means the compilation directory of the source file.\n\
1943 GDB ensures the search path always ends with $cdir:$cwd by\n\
1944 appending these directories if necessary.\n\
1945 Setting the value to an empty string sets it to $cdir:$cwd, the default."),
1946 set_directories_command
,
1947 show_directories_command
,
1948 &setlist
, &showlist
);
1950 add_info ("source", info_source_command
,
1951 _("Information about the current source file."));
1953 add_info ("line", info_line_command
, _("\
1954 Core addresses of the code for a source line.\n\
1955 Line can be specified as\n\
1956 LINENUM, to list around that line in current file,\n\
1957 FILE:LINENUM, to list around that line in that file,\n\
1958 FUNCTION, to list around beginning of that function,\n\
1959 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1960 Default is to describe the last source line that was listed.\n\n\
1961 This sets the default address for \"x\" to the line's first instruction\n\
1962 so that \"x/i\" suffices to start examining the machine code.\n\
1963 The address is also stored as the value of \"$_\"."));
1965 cmd_list_element
*forward_search_cmd
1966 = add_com ("forward-search", class_files
, forward_search_command
, _("\
1967 Search for regular expression (see regex(3)) from last line listed.\n\
1968 The matching line number is also stored as the value of \"$_\"."));
1969 add_com_alias ("search", forward_search_cmd
, class_files
, 0);
1970 add_com_alias ("fo", forward_search_cmd
, class_files
, 1);
1972 cmd_list_element
*reverse_search_cmd
1973 = add_com ("reverse-search", class_files
, reverse_search_command
, _("\
1974 Search backward for regular expression (see regex(3)) from last line listed.\n\
1975 The matching line number is also stored as the value of \"$_\"."));
1976 add_com_alias ("rev", reverse_search_cmd
, class_files
, 1);
1978 add_setshow_integer_cmd ("listsize", class_support
, &lines_to_list
, _("\
1979 Set number of source lines gdb will list by default."), _("\
1980 Show number of source lines gdb will list by default."), _("\
1981 Use this to choose how many source lines the \"list\" displays (unless\n\
1982 the \"list\" argument explicitly specifies some other number).\n\
1983 A value of \"unlimited\", or zero, means there's no limit."),
1986 &setlist
, &showlist
);
1988 add_cmd ("substitute-path", class_files
, set_substitute_path_command
,
1990 Add a substitution rule to rewrite the source directories.\n\
1991 Usage: set substitute-path FROM TO\n\
1992 The rule is applied only if the directory name starts with FROM\n\
1993 directly followed by a directory separator.\n\
1994 If a substitution rule was previously set for FROM, the old rule\n\
1995 is replaced by the new one."),
1998 add_cmd ("substitute-path", class_files
, unset_substitute_path_command
,
2000 Delete one or all substitution rules rewriting the source directories.\n\
2001 Usage: unset substitute-path [FROM]\n\
2002 Delete the rule for substituting FROM in source directories. If FROM\n\
2003 is not specified, all substituting rules are deleted.\n\
2004 If the debugger cannot find a rule for FROM, it will display a warning."),
2007 add_cmd ("substitute-path", class_files
, show_substitute_path_command
,
2009 Show one or all substitution rules rewriting the source directories.\n\
2010 Usage: show substitute-path [FROM]\n\
2011 Print the rule for substituting FROM in source directories. If FROM\n\
2012 is not specified, print all substitution rules."),
2015 add_setshow_enum_cmd ("filename-display", class_files
,
2016 filename_display_kind_names
,
2017 &filename_display_string
, _("\
2018 Set how to display filenames."), _("\
2019 Show how to display filenames."), _("\
2020 filename-display can be:\n\
2021 basename - display only basename of a filename\n\
2022 relative - display a filename relative to the compilation directory\n\
2023 absolute - display an absolute filename\n\
2024 By default, relative filenames are displayed."),
2026 show_filename_display_string
,
2027 &setlist
, &showlist
);
2029 add_prefix_cmd ("source", no_class
, set_source
,
2030 _("Generic command for setting how sources are handled."),
2031 &setsourcelist
, 0, &setlist
);
2033 add_prefix_cmd ("source", no_class
, show_source
,
2034 _("Generic command for showing source settings."),
2035 &showsourcelist
, 0, &showlist
);
2037 add_setshow_boolean_cmd ("open", class_files
, &source_open
, _("\
2038 Set whether GDB should open source files."), _("\
2039 Show whether GDB should open source files."), _("\
2040 When this option is on GDB will open source files and display the\n\
2041 contents when appropriate, for example, when GDB stops, or the list\n\
2043 When this option is off GDB will not try to open source files, instead\n\
2044 GDB will print the file and line number that would have been displayed.\n\
2045 This can be useful if access to source code files is slow, for example\n\
2046 due to the source being located over a slow network connection."),
2049 &setsourcelist
, &showsourcelist
);