1 /* List lines of source files for GDB, the GNU debugger.
2 Copyright (C) 1986-2019 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 "gdb_regex.h"
40 #include "filenames.h" /* for DOSish file names */
41 #include "completer.h"
43 #include "readline/readline.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"
51 #define OPEN_MODE (O_RDONLY | O_BINARY)
52 #define FDOPEN_MODE FOPEN_RB
54 /* Path of directories to search for source files.
55 Same format as the PATH environment variable's value. */
59 /* Support for source path substitution commands. */
61 struct substitute_path_rule
65 struct substitute_path_rule
*next
;
68 static struct substitute_path_rule
*substitute_path_rules
= NULL
;
70 /* An instance of this is attached to each program space. */
72 struct current_source_location
74 /* Symtab of default file for listing lines of. */
76 struct symtab
*symtab
= nullptr;
78 /* Default next line to list. */
83 static program_space_key
<current_source_location
> current_source_key
;
85 /* Default number of lines to print with commands like "list".
86 This is based on guessing how many long (i.e. more than chars_per_line
87 characters) lines there will be. To be completely correct, "list"
88 and friends should be rewritten to count characters and see where
89 things are wrapping, but that would be a fair amount of work. */
91 static int lines_to_list
= 10;
93 show_lines_to_list (struct ui_file
*file
, int from_tty
,
94 struct cmd_list_element
*c
, const char *value
)
96 fprintf_filtered (file
,
97 _("Number of source lines gdb "
98 "will list by default is %s.\n"),
102 /* Possible values of 'set filename-display'. */
103 static const char filename_display_basename
[] = "basename";
104 static const char filename_display_relative
[] = "relative";
105 static const char filename_display_absolute
[] = "absolute";
107 static const char *const filename_display_kind_names
[] = {
108 filename_display_basename
,
109 filename_display_relative
,
110 filename_display_absolute
,
114 static const char *filename_display_string
= filename_display_relative
;
117 show_filename_display_string (struct ui_file
*file
, int from_tty
,
118 struct cmd_list_element
*c
, const char *value
)
120 fprintf_filtered (file
, _("Filenames are displayed as \"%s\".\n"), value
);
123 /* Line number of last line printed. Default for various commands.
124 current_source_line is usually, but not always, the same as this. */
126 static int last_line_listed
;
128 /* First line number listed by last listing command. If 0, then no
129 source lines have yet been listed since the last time the current
130 source line was changed. */
132 static int first_line_listed
;
134 /* Saves the name of the last source file visited and a possible error code.
135 Used to prevent repeating annoying "No such file or directories" msgs. */
137 static struct symtab
*last_source_visited
= NULL
;
138 static bool last_source_error
= false;
140 /* Return the first line listed by print_source_lines.
141 Used by command interpreters to request listing from
145 get_first_line_listed (void)
147 return first_line_listed
;
150 /* Clear line listed range. This makes the next "list" center the
151 printed source lines around the current source line. */
154 clear_lines_listed_range (void)
156 first_line_listed
= 0;
157 last_line_listed
= 0;
160 /* Return the default number of lines to print with commands like the
161 cli "list". The caller of print_source_lines must use this to
162 calculate the end line and use it in the call to print_source_lines
163 as it does not automatically use this value. */
166 get_lines_to_list (void)
168 return lines_to_list
;
171 /* A helper to return the current source location object for PSPACE,
172 creating it if it does not exist. */
174 static current_source_location
*
175 get_source_location (program_space
*pspace
)
177 current_source_location
*loc
178 = current_source_key
.get (pspace
);
180 loc
= current_source_key
.emplace (pspace
);
184 /* Return the current source file for listing and next line to list.
185 NOTE: The returned sal pc and end fields are not valid. */
187 struct symtab_and_line
188 get_current_source_symtab_and_line (void)
190 symtab_and_line cursal
;
191 current_source_location
*loc
= get_source_location (current_program_space
);
193 cursal
.pspace
= current_program_space
;
194 cursal
.symtab
= loc
->symtab
;
195 cursal
.line
= loc
->line
;
202 /* If the current source file for listing is not set, try and get a default.
203 Usually called before get_current_source_symtab_and_line() is called.
204 It may err out if a default cannot be determined.
205 We must be cautious about where it is called, as it can recurse as the
206 process of determining a new default may call the caller!
207 Use get_current_source_symtab_and_line only to get whatever
208 we have without erroring out or trying to get a default. */
211 set_default_source_symtab_and_line (void)
213 if (!have_full_symbols () && !have_partial_symbols ())
214 error (_("No symbol table is loaded. Use the \"file\" command."));
216 /* Pull in a current source symtab if necessary. */
217 current_source_location
*loc
= get_source_location (current_program_space
);
218 if (loc
->symtab
== nullptr)
219 select_source_symtab (0);
222 /* Return the current default file for listing and next line to list
223 (the returned sal pc and end fields are not valid.)
224 and set the current default to whatever is in SAL.
225 NOTE: The returned sal pc and end fields are not valid. */
227 struct symtab_and_line
228 set_current_source_symtab_and_line (const symtab_and_line
&sal
)
230 symtab_and_line cursal
;
232 current_source_location
*loc
= get_source_location (sal
.pspace
);
234 cursal
.pspace
= sal
.pspace
;
235 cursal
.symtab
= loc
->symtab
;
236 cursal
.line
= loc
->line
;
240 loc
->symtab
= sal
.symtab
;
241 loc
->line
= sal
.line
;
243 /* Force the next "list" to center around the current line. */
244 clear_lines_listed_range ();
249 /* Reset any information stored about a default file and line to print. */
252 clear_current_source_symtab_and_line (void)
254 current_source_location
*loc
= get_source_location (current_program_space
);
255 loc
->symtab
= nullptr;
262 select_source_symtab (struct symtab
*s
)
266 current_source_location
*loc
267 = get_source_location (SYMTAB_PSPACE (s
));
273 current_source_location
*loc
= get_source_location (current_program_space
);
274 if (loc
->symtab
!= nullptr)
277 /* Make the default place to list be the function `main'
279 block_symbol bsym
= lookup_symbol (main_name (), 0, VAR_DOMAIN
, 0);
280 if (bsym
.symbol
!= nullptr && SYMBOL_CLASS (bsym
.symbol
) == LOC_BLOCK
)
282 symtab_and_line sal
= find_function_start_sal (bsym
.symbol
, true);
283 loc
->symtab
= sal
.symtab
;
284 loc
->line
= std::max (sal
.line
- (lines_to_list
- 1), 1);
288 /* Alright; find the last file in the symtab list (ignoring .h's
289 and namespace symtabs). */
293 for (objfile
*ofp
: current_program_space
->objfiles ())
295 for (compunit_symtab
*cu
: ofp
->compunits ())
297 for (symtab
*symtab
: compunit_filetabs (cu
))
299 const char *name
= symtab
->filename
;
300 int len
= strlen (name
);
302 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
303 || strcmp (name
, "<<C++-namespaces>>") == 0)))
304 loc
->symtab
= symtab
;
309 if (loc
->symtab
!= nullptr)
312 for (objfile
*objfile
: current_program_space
->objfiles ())
315 s
= objfile
->sf
->qf
->find_last_source_symtab (objfile
);
319 if (loc
->symtab
!= nullptr)
322 error (_("Can't find a default source file"));
325 /* Handler for "set directories path-list" command.
326 "set dir mumble" doesn't prepend paths, it resets the entire
327 path list. The theory is that set(show(dir)) should be a no-op. */
330 set_directories_command (const char *args
,
331 int from_tty
, struct cmd_list_element
*c
)
333 /* This is the value that was set.
334 It needs to be processed to maintain $cdir:$cwd and remove dups. */
335 char *set_path
= source_path
;
337 /* We preserve the invariant that $cdir:$cwd begins life at the end of
338 the list by calling init_source_path. If they appear earlier in
339 SET_PATH then mod_path will move them appropriately.
340 mod_path will also remove duplicates. */
342 if (*set_path
!= '\0')
343 mod_path (set_path
, &source_path
);
348 /* Print the list of source directories.
349 This is used by the "ld" command, so it has the signature of a command
353 show_directories_1 (char *ignore
, int from_tty
)
355 puts_filtered ("Source directories searched: ");
356 puts_filtered (source_path
);
357 puts_filtered ("\n");
360 /* Handler for "show directories" command. */
363 show_directories_command (struct ui_file
*file
, int from_tty
,
364 struct cmd_list_element
*c
, const char *value
)
366 show_directories_1 (NULL
, from_tty
);
372 forget_cached_source_info_for_objfile (struct objfile
*objfile
)
374 for (compunit_symtab
*cu
: objfile
->compunits ())
376 for (symtab
*s
: compunit_filetabs (cu
))
378 if (s
->fullname
!= NULL
)
387 objfile
->sf
->qf
->forget_cached_source_info (objfile
);
393 forget_cached_source_info (void)
395 struct program_space
*pspace
;
398 for (objfile
*objfile
: pspace
->objfiles ())
400 forget_cached_source_info_for_objfile (objfile
);
403 g_source_cache
.clear ();
404 last_source_visited
= NULL
;
408 init_source_path (void)
412 xsnprintf (buf
, sizeof (buf
), "$cdir%c$cwd", DIRNAME_SEPARATOR
);
413 source_path
= xstrdup (buf
);
414 forget_cached_source_info ();
417 /* Add zero or more directories to the front of the source path. */
420 directory_command (const char *dirname
, int from_tty
)
423 /* FIXME, this goes to "delete dir"... */
426 if (!from_tty
|| query (_("Reinitialize source path to empty? ")))
434 mod_path (dirname
, &source_path
);
435 forget_cached_source_info ();
438 show_directories_1 ((char *) 0, from_tty
);
441 /* Add a path given with the -d command line switch.
442 This will not be quoted so we must not treat spaces as separators. */
445 directory_switch (const char *dirname
, int from_tty
)
447 add_path (dirname
, &source_path
, 0);
450 /* Add zero or more directories to the front of an arbitrary path. */
453 mod_path (const char *dirname
, char **which_path
)
455 add_path (dirname
, which_path
, 1);
458 /* Workhorse of mod_path. Takes an extra argument to determine
459 if dirname should be parsed for separators that indicate multiple
460 directories. This allows for interfaces that pre-parse the dirname
461 and allow specification of traditional separator characters such
465 add_path (const char *dirname
, char **which_path
, int parse_separators
)
467 char *old
= *which_path
;
469 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
;
474 if (parse_separators
)
476 /* This will properly parse the space and tab separators
477 and any quotes that may exist. */
478 gdb_argv
argv (dirname
);
480 for (char *arg
: argv
)
481 dirnames_to_char_ptr_vec_append (&dir_vec
, arg
);
484 dir_vec
.emplace_back (xstrdup (dirname
));
486 for (const gdb::unique_xmalloc_ptr
<char> &name_up
: dir_vec
)
488 char *name
= name_up
.get ();
491 gdb::unique_xmalloc_ptr
<char> new_name_holder
;
493 /* Spaces and tabs will have been removed by buildargv().
494 NAME is the start of the directory.
495 P is the '\0' following the end. */
496 p
= name
+ strlen (name
);
498 while (!(IS_DIR_SEPARATOR (*name
) && p
<= name
+ 1) /* "/" */
499 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
500 /* On MS-DOS and MS-Windows, h:\ is different from h: */
501 && !(p
== name
+ 3 && name
[1] == ':') /* "d:/" */
503 && IS_DIR_SEPARATOR (p
[-1]))
504 /* Sigh. "foo/" => "foo" */
508 while (p
> name
&& p
[-1] == '.')
512 /* "." => getwd (). */
513 name
= current_directory
;
516 else if (p
> name
+ 1 && IS_DIR_SEPARATOR (p
[-2]))
526 /* "...foo/." => "...foo". */
537 new_name_holder
.reset (tilde_expand (name
));
538 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
539 else if (IS_ABSOLUTE_PATH (name
) && p
== name
+ 2) /* "d:" => "d:." */
540 new_name_holder
.reset (concat (name
, ".", (char *) NULL
));
542 else if (!IS_ABSOLUTE_PATH (name
) && name
[0] != '$')
543 new_name_holder
.reset (concat (current_directory
, SLASH_STRING
, name
,
546 new_name_holder
.reset (savestring (name
, p
- name
));
547 name
= new_name_holder
.get ();
549 /* Unless it's a variable, check existence. */
552 /* These are warnings, not errors, since we don't want a
553 non-existent directory in a .gdbinit file to stop processing
554 of the .gdbinit file.
556 Whether they get added to the path is more debatable. Current
557 answer is yes, in case the user wants to go make the directory
558 or whatever. If the directory continues to not exist/not be
559 a directory/etc, then having them in the path should be
561 if (stat (name
, &st
) < 0)
563 int save_errno
= errno
;
565 fprintf_unfiltered (gdb_stderr
, "Warning: ");
566 print_sys_errmsg (name
, save_errno
);
568 else if ((st
.st_mode
& S_IFMT
) != S_IFDIR
)
569 warning (_("%s is not a directory."), name
);
574 unsigned int len
= strlen (name
);
580 /* FIXME: we should use realpath() or its work-alike
581 before comparing. Then all the code above which
582 removes excess slashes and dots could simply go away. */
583 if (!filename_ncmp (p
, name
, len
)
584 && (p
[len
] == '\0' || p
[len
] == DIRNAME_SEPARATOR
))
586 /* Found it in the search path, remove old copy. */
589 /* Back over leading separator. */
592 if (prefix
> p
- *which_path
)
594 /* Same dir twice in one cmd. */
597 /* Copy from next '\0' or ':'. */
598 memmove (p
, &p
[len
+ 1], strlen (&p
[len
+ 1]) + 1);
600 p
= strchr (p
, DIRNAME_SEPARATOR
);
607 tinybuf
[0] = DIRNAME_SEPARATOR
;
610 /* If we have already tacked on a name(s) in this command,
611 be sure they stay on the front as we tack on some
619 temp
= concat (old
, tinybuf
, name
, (char *)NULL
);
621 *which_path
= concat (temp
, "", &old
[prefix
], (char *) NULL
);
622 prefix
= strlen (temp
);
627 *which_path
= concat (name
, (old
[0] ? tinybuf
: old
),
629 prefix
= strlen (name
);
641 info_source_command (const char *ignore
, int from_tty
)
643 current_source_location
*loc
644 = get_source_location (current_program_space
);
645 struct symtab
*s
= loc
->symtab
;
646 struct compunit_symtab
*cust
;
650 printf_filtered (_("No current source file.\n"));
654 cust
= SYMTAB_COMPUNIT (s
);
655 printf_filtered (_("Current source file is %s\n"), s
->filename
);
656 if (SYMTAB_DIRNAME (s
) != NULL
)
657 printf_filtered (_("Compilation directory is %s\n"), SYMTAB_DIRNAME (s
));
659 printf_filtered (_("Located in %s\n"), s
->fullname
);
660 const std::vector
<off_t
> *offsets
;
661 if (g_source_cache
.get_line_charpos (s
, &offsets
))
662 printf_filtered (_("Contains %d line%s.\n"), (int) offsets
->size (),
663 offsets
->size () == 1 ? "" : "s");
665 printf_filtered (_("Source language is %s.\n"), language_str (s
->language
));
666 printf_filtered (_("Producer is %s.\n"),
667 COMPUNIT_PRODUCER (cust
) != NULL
668 ? COMPUNIT_PRODUCER (cust
) : _("unknown"));
669 printf_filtered (_("Compiled with %s debugging format.\n"),
670 COMPUNIT_DEBUGFORMAT (cust
));
671 printf_filtered (_("%s preprocessor macro info.\n"),
672 COMPUNIT_MACRO_TABLE (cust
) != NULL
673 ? "Includes" : "Does not include");
677 /* Helper function to remove characters from the start of PATH so that
678 PATH can then be appended to a directory name. We remove leading drive
679 letters (for dos) as well as leading '/' characters and './'
683 prepare_path_for_appending (const char *path
)
685 /* For dos paths, d:/foo -> /foo, and d:foo -> foo. */
686 if (HAS_DRIVE_SPEC (path
))
687 path
= STRIP_DRIVE_SPEC (path
);
689 const char *old_path
;
694 /* /foo => foo, to avoid multiple slashes that Emacs doesn't like. */
695 while (IS_DIR_SEPARATOR(path
[0]))
699 while (path
[0] == '.' && IS_DIR_SEPARATOR (path
[1]))
702 while (old_path
!= path
);
707 /* Open a file named STRING, searching path PATH (dir names sep by some char)
708 using mode MODE in the calls to open. You cannot use this function to
709 create files (O_CREAT).
711 OPTS specifies the function behaviour in specific cases.
713 If OPF_TRY_CWD_FIRST, try to open ./STRING before searching PATH.
714 (ie pretend the first element of PATH is "."). This also indicates
715 that, unless OPF_SEARCH_IN_PATH is also specified, a slash in STRING
716 disables searching of the path (this is so that "exec-file ./foo" or
717 "symbol-file ./foo" insures that you get that particular version of
718 foo or an error message).
720 If OPTS has OPF_SEARCH_IN_PATH set, absolute names will also be
721 searched in path (we usually want this for source files but not for
724 If FILENAME_OPENED is non-null, set it to a newly allocated string naming
725 the actual file opened (this string will always start with a "/"). We
726 have to take special pains to avoid doubling the "/" between the directory
727 and the file, sigh! Emacs gets confuzzed by this when we print the
730 If OPTS has OPF_RETURN_REALPATH set return FILENAME_OPENED resolved by
731 gdb_realpath. Even without OPF_RETURN_REALPATH this function still returns
732 filename starting with "/". If FILENAME_OPENED is NULL this option has no
735 If a file is found, return the descriptor.
736 Otherwise, return -1, with errno set for the last name we tried to open. */
738 /* >>>> This should only allow files of certain types,
739 >>>> eg executable, non-directory. */
741 openp (const char *path
, openp_flags opts
, const char *string
,
742 int mode
, gdb::unique_xmalloc_ptr
<char> *filename_opened
)
747 /* The errno set for the last name we tried to open (and
750 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
;
752 /* The open syscall MODE parameter is not specified. */
753 gdb_assert ((mode
& O_CREAT
) == 0);
754 gdb_assert (string
!= NULL
);
756 /* A file with an empty name cannot possibly exist. Report a failure
757 without further checking.
759 This is an optimization which also defends us against buggy
760 implementations of the "stat" function. For instance, we have
761 noticed that a MinGW debugger built on Windows XP 32bits crashes
762 when the debugger is started with an empty argument. */
763 if (string
[0] == '\0')
774 if ((opts
& OPF_TRY_CWD_FIRST
) || IS_ABSOLUTE_PATH (string
))
776 int i
, reg_file_errno
;
778 if (is_regular_file (string
, ®_file_errno
))
780 filename
= (char *) alloca (strlen (string
) + 1);
781 strcpy (filename
, string
);
782 fd
= gdb_open_cloexec (filename
, mode
, 0);
791 last_errno
= reg_file_errno
;
794 if (!(opts
& OPF_SEARCH_IN_PATH
))
795 for (i
= 0; string
[i
]; i
++)
796 if (IS_DIR_SEPARATOR (string
[i
]))
800 /* Remove characters from the start of PATH that we don't need when PATH
801 is appended to a directory name. */
802 string
= prepare_path_for_appending (string
);
804 alloclen
= strlen (path
) + strlen (string
) + 2;
805 filename
= (char *) alloca (alloclen
);
809 dir_vec
= dirnames_to_char_ptr_vec (path
);
811 for (const gdb::unique_xmalloc_ptr
<char> &dir_up
: dir_vec
)
813 char *dir
= dir_up
.get ();
814 size_t len
= strlen (dir
);
817 if (strcmp (dir
, "$cwd") == 0)
819 /* Name is $cwd -- insert current directory name instead. */
822 /* First, realloc the filename buffer if too short. */
823 len
= strlen (current_directory
);
824 newlen
= len
+ strlen (string
) + 2;
825 if (newlen
> alloclen
)
828 filename
= (char *) alloca (alloclen
);
830 strcpy (filename
, current_directory
);
832 else if (strchr(dir
, '~'))
834 /* See whether we need to expand the tilde. */
837 gdb::unique_xmalloc_ptr
<char> tilde_expanded (tilde_expand (dir
));
839 /* First, realloc the filename buffer if too short. */
840 len
= strlen (tilde_expanded
.get ());
841 newlen
= len
+ strlen (string
) + 2;
842 if (newlen
> alloclen
)
845 filename
= (char *) alloca (alloclen
);
847 strcpy (filename
, tilde_expanded
.get ());
851 /* Normal file name in path -- just use it. */
852 strcpy (filename
, dir
);
854 /* Don't search $cdir. It's also a magic path like $cwd, but we
855 don't have enough information to expand it. The user *could*
856 have an actual directory named '$cdir' but handling that would
857 be confusing, it would mean different things in different
858 contexts. If the user really has '$cdir' one can use './$cdir'.
859 We can get $cdir when loading scripts. When loading source files
860 $cdir must have already been expanded to the correct value. */
861 if (strcmp (dir
, "$cdir") == 0)
865 /* Remove trailing slashes. */
866 while (len
> 0 && IS_DIR_SEPARATOR (filename
[len
- 1]))
869 strcat (filename
+ len
, SLASH_STRING
);
870 strcat (filename
, string
);
872 if (is_regular_file (filename
, ®_file_errno
))
874 fd
= gdb_open_cloexec (filename
, mode
, 0);
880 last_errno
= reg_file_errno
;
886 /* If a file was opened, canonicalize its filename. */
888 filename_opened
->reset (NULL
);
889 else if ((opts
& OPF_RETURN_REALPATH
) != 0)
890 *filename_opened
= gdb_realpath (filename
);
892 *filename_opened
= gdb_abspath (filename
);
900 /* This is essentially a convenience, for clients that want the behaviour
901 of openp, using source_path, but that really don't want the file to be
902 opened but want instead just to know what the full pathname is (as
903 qualified against source_path).
905 The current working directory is searched first.
907 If the file was found, this function returns 1, and FULL_PATHNAME is
908 set to the fully-qualified pathname.
910 Else, this functions returns 0, and FULL_PATHNAME is set to NULL. */
912 source_full_path_of (const char *filename
,
913 gdb::unique_xmalloc_ptr
<char> *full_pathname
)
917 fd
= openp (source_path
,
918 OPF_TRY_CWD_FIRST
| OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
,
919 filename
, O_RDONLY
, full_pathname
);
922 full_pathname
->reset (NULL
);
930 /* Return non-zero if RULE matches PATH, that is if the rule can be
934 substitute_path_rule_matches (const struct substitute_path_rule
*rule
,
937 const int from_len
= strlen (rule
->from
);
938 const int path_len
= strlen (path
);
940 if (path_len
< from_len
)
943 /* The substitution rules are anchored at the start of the path,
944 so the path should start with rule->from. */
946 if (filename_ncmp (path
, rule
->from
, from_len
) != 0)
949 /* Make sure that the region in the path that matches the substitution
950 rule is immediately followed by a directory separator (or the end of
951 string character). */
953 if (path
[from_len
] != '\0' && !IS_DIR_SEPARATOR (path
[from_len
]))
959 /* Find the substitute-path rule that applies to PATH and return it.
960 Return NULL if no rule applies. */
962 static struct substitute_path_rule
*
963 get_substitute_path_rule (const char *path
)
965 struct substitute_path_rule
*rule
= substitute_path_rules
;
967 while (rule
!= NULL
&& !substitute_path_rule_matches (rule
, path
))
973 /* If the user specified a source path substitution rule that applies
974 to PATH, then apply it and return the new path.
976 Return NULL if no substitution rule was specified by the user,
977 or if no rule applied to the given PATH. */
979 gdb::unique_xmalloc_ptr
<char>
980 rewrite_source_path (const char *path
)
982 const struct substitute_path_rule
*rule
= get_substitute_path_rule (path
);
989 from_len
= strlen (rule
->from
);
991 /* Compute the rewritten path and return it. */
994 (char *) xmalloc (strlen (path
) + 1 + strlen (rule
->to
) - from_len
);
995 strcpy (new_path
, rule
->to
);
996 strcat (new_path
, path
+ from_len
);
998 return gdb::unique_xmalloc_ptr
<char> (new_path
);
1004 find_and_open_source (const char *filename
,
1005 const char *dirname
,
1006 gdb::unique_xmalloc_ptr
<char> *fullname
)
1008 char *path
= source_path
;
1012 /* Quick way out if we already know its full name. */
1016 /* The user may have requested that source paths be rewritten
1017 according to substitution rules he provided. If a substitution
1018 rule applies to this path, then apply it. */
1019 gdb::unique_xmalloc_ptr
<char> rewritten_fullname
1020 = rewrite_source_path (fullname
->get ());
1022 if (rewritten_fullname
!= NULL
)
1023 *fullname
= std::move (rewritten_fullname
);
1025 result
= gdb_open_cloexec (fullname
->get (), OPEN_MODE
, 0);
1028 if (basenames_may_differ
)
1029 *fullname
= gdb_realpath (fullname
->get ());
1031 *fullname
= gdb_abspath (fullname
->get ());
1032 return scoped_fd (result
);
1035 /* Didn't work -- free old one, try again. */
1036 fullname
->reset (NULL
);
1039 gdb::unique_xmalloc_ptr
<char> rewritten_dirname
;
1040 if (dirname
!= NULL
)
1042 /* If necessary, rewrite the compilation directory name according
1043 to the source path substitution rules specified by the user. */
1045 rewritten_dirname
= rewrite_source_path (dirname
);
1047 if (rewritten_dirname
!= NULL
)
1048 dirname
= rewritten_dirname
.get ();
1050 /* Replace a path entry of $cdir with the compilation directory
1053 p
= strstr (source_path
, "$cdir");
1054 if (p
&& (p
== path
|| p
[-1] == DIRNAME_SEPARATOR
)
1055 && (p
[cdir_len
] == DIRNAME_SEPARATOR
|| p
[cdir_len
] == '\0'))
1060 alloca (strlen (source_path
) + 1 + strlen (dirname
) + 1);
1061 len
= p
- source_path
;
1062 strncpy (path
, source_path
, len
); /* Before $cdir */
1063 strcpy (path
+ len
, dirname
); /* new stuff */
1064 strcat (path
+ len
, source_path
+ len
+ cdir_len
); /* After
1069 gdb::unique_xmalloc_ptr
<char> rewritten_filename
1070 = rewrite_source_path (filename
);
1072 if (rewritten_filename
!= NULL
)
1073 filename
= rewritten_filename
.get ();
1075 openp_flags flags
= OPF_SEARCH_IN_PATH
;
1076 if (basenames_may_differ
)
1077 flags
|= OPF_RETURN_REALPATH
;
1079 /* Try to locate file using filename. */
1080 result
= openp (path
, flags
, filename
, OPEN_MODE
, fullname
);
1081 if (result
< 0 && dirname
!= NULL
)
1083 /* Remove characters from the start of PATH that we don't need when
1084 PATH is appended to a directory name. */
1085 const char *filename_start
= prepare_path_for_appending (filename
);
1087 /* Try to locate file using compilation dir + filename. This is
1088 helpful if part of the compilation directory was removed,
1089 e.g. using gcc's -fdebug-prefix-map, and we have added the missing
1090 prefix to source_path. */
1091 std::string
cdir_filename (dirname
);
1093 /* Remove any trailing directory separators. */
1094 while (IS_DIR_SEPARATOR (cdir_filename
.back ()))
1095 cdir_filename
.pop_back ();
1097 /* Add our own directory separator. */
1098 cdir_filename
.append (SLASH_STRING
);
1099 cdir_filename
.append (filename_start
);
1101 result
= openp (path
, flags
, cdir_filename
.c_str (), OPEN_MODE
,
1106 /* Didn't work. Try using just the basename. */
1107 p
= lbasename (filename
);
1109 result
= openp (path
, flags
, p
, OPEN_MODE
, fullname
);
1112 return scoped_fd (result
);
1115 /* Open a source file given a symtab S. Returns a file descriptor or
1116 negative number for error.
1118 This function is a convience function to find_and_open_source. */
1121 open_source_file (struct symtab
*s
)
1124 return scoped_fd (-1);
1126 gdb::unique_xmalloc_ptr
<char> fullname (s
->fullname
);
1128 scoped_fd fd
= find_and_open_source (s
->filename
, SYMTAB_DIRNAME (s
),
1130 s
->fullname
= fullname
.release ();
1134 /* Finds the fullname that a symtab represents.
1136 This functions finds the fullname and saves it in s->fullname.
1137 It will also return the value.
1139 If this function fails to find the file that this symtab represents,
1140 the expected fullname is used. Therefore the files does not have to
1144 symtab_to_fullname (struct symtab
*s
)
1146 /* Use cached copy if we have it.
1147 We rely on forget_cached_source_info being called appropriately
1148 to handle cases like the file being moved. */
1149 if (s
->fullname
== NULL
)
1151 scoped_fd fd
= open_source_file (s
);
1155 gdb::unique_xmalloc_ptr
<char> fullname
;
1157 /* rewrite_source_path would be applied by find_and_open_source, we
1158 should report the pathname where GDB tried to find the file. */
1160 if (SYMTAB_DIRNAME (s
) == NULL
|| IS_ABSOLUTE_PATH (s
->filename
))
1161 fullname
.reset (xstrdup (s
->filename
));
1163 fullname
.reset (concat (SYMTAB_DIRNAME (s
), SLASH_STRING
,
1164 s
->filename
, (char *) NULL
));
1166 s
->fullname
= rewrite_source_path (fullname
.get ()).release ();
1167 if (s
->fullname
== NULL
)
1168 s
->fullname
= fullname
.release ();
1175 /* See commentary in source.h. */
1178 symtab_to_filename_for_display (struct symtab
*symtab
)
1180 if (filename_display_string
== filename_display_basename
)
1181 return lbasename (symtab
->filename
);
1182 else if (filename_display_string
== filename_display_absolute
)
1183 return symtab_to_fullname (symtab
);
1184 else if (filename_display_string
== filename_display_relative
)
1185 return symtab
->filename
;
1187 internal_error (__FILE__
, __LINE__
, _("invalid filename_display_string"));
1192 /* Print source lines from the file of symtab S,
1193 starting with line number LINE and stopping before line number STOPLINE. */
1196 print_source_lines_base (struct symtab
*s
, int line
, int stopline
,
1197 print_source_lines_flags flags
)
1199 bool noprint
= false;
1200 int nlines
= stopline
- line
;
1201 struct ui_out
*uiout
= current_uiout
;
1203 /* Regardless of whether we can open the file, set current_source_symtab. */
1204 current_source_location
*loc
1205 = get_source_location (current_program_space
);
1209 first_line_listed
= line
;
1211 /* If printing of source lines is disabled, just print file and line
1213 if (uiout
->test_flags (ui_source_list
))
1215 /* Only prints "No such file or directory" once. */
1216 if (s
== last_source_visited
)
1218 if (last_source_error
)
1220 flags
|= PRINT_SOURCE_LINES_NOERROR
;
1226 last_source_visited
= s
;
1227 scoped_fd desc
= open_source_file (s
);
1228 last_source_error
= desc
.get () < 0;
1229 if (last_source_error
)
1235 flags
|= PRINT_SOURCE_LINES_NOERROR
;
1241 if (!(flags
& PRINT_SOURCE_LINES_NOERROR
))
1243 const char *filename
= symtab_to_filename_for_display (s
);
1244 int len
= strlen (filename
) + 100;
1245 char *name
= (char *) alloca (len
);
1247 xsnprintf (name
, len
, "%d\t%s", line
, filename
);
1248 print_sys_errmsg (name
, errno
);
1252 uiout
->field_signed ("line", line
);
1253 uiout
->text ("\tin ");
1255 /* CLI expects only the "file" field. TUI expects only the
1256 "fullname" field (and TUI does break if "file" is printed).
1257 MI expects both fields. ui_source_list is set only for CLI,
1259 if (uiout
->is_mi_like_p () || uiout
->test_flags (ui_source_list
))
1260 uiout
->field_string ("file", symtab_to_filename_for_display (s
),
1261 file_name_style
.style ());
1262 if (uiout
->is_mi_like_p () || !uiout
->test_flags (ui_source_list
))
1264 const char *s_fullname
= symtab_to_fullname (s
);
1265 char *local_fullname
;
1267 /* ui_out_field_string may free S_FULLNAME by calling
1268 open_source_file for it again. See e.g.,
1269 tui_field_string->tui_show_source. */
1270 local_fullname
= (char *) alloca (strlen (s_fullname
) + 1);
1271 strcpy (local_fullname
, s_fullname
);
1273 uiout
->field_string ("fullname", local_fullname
);
1282 /* If the user requested a sequence of lines that seems to go backward
1283 (from high to low line numbers) then we don't print anything. */
1284 if (stopline
<= line
)
1288 if (!g_source_cache
.get_source_lines (s
, line
, stopline
- 1, &lines
))
1290 const std::vector
<off_t
> *offsets
= nullptr;
1291 g_source_cache
.get_line_charpos (s
, &offsets
);
1292 error (_("Line number %d out of range; %s has %d lines."),
1293 line
, symtab_to_filename_for_display (s
),
1294 offsets
== nullptr ? 0 : (int) offsets
->size ());
1297 const char *iter
= lines
.c_str ();
1298 while (nlines
-- > 0 && *iter
!= '\0')
1302 last_line_listed
= loc
->line
;
1303 if (flags
& PRINT_SOURCE_LINES_FILENAME
)
1305 uiout
->text (symtab_to_filename_for_display (s
));
1308 xsnprintf (buf
, sizeof (buf
), "%d\t", loc
->line
++);
1311 while (*iter
!= '\0')
1313 /* Find a run of characters that can be emitted at once.
1314 This is done so that escape sequences are kept
1316 const char *start
= iter
;
1322 if (c
== '\033' && skip_ansi_escape (iter
, &skip_bytes
))
1324 else if (c
>= 0 && c
< 040 && c
!= '\t')
1333 std::string
text (start
, iter
);
1334 uiout
->text (text
.c_str ());
1338 /* Treat either \r or \r\n as a single newline. */
1344 else if (*iter
== '\n')
1349 else if (*iter
> 0 && *iter
< 040)
1351 xsnprintf (buf
, sizeof (buf
), "^%c", *iter
+ 0100);
1355 else if (*iter
== 0177)
1369 print_source_lines (struct symtab
*s
, int line
, int stopline
,
1370 print_source_lines_flags flags
)
1372 print_source_lines_base (s
, line
, stopline
, flags
);
1378 print_source_lines (struct symtab
*s
, source_lines_range line_range
,
1379 print_source_lines_flags flags
)
1381 print_source_lines_base (s
, line_range
.startline (),
1382 line_range
.stopline (), flags
);
1387 /* Print info on range of pc's in a specified line. */
1390 info_line_command (const char *arg
, int from_tty
)
1392 CORE_ADDR start_pc
, end_pc
;
1394 std::vector
<symtab_and_line
> decoded_sals
;
1395 symtab_and_line curr_sal
;
1396 gdb::array_view
<symtab_and_line
> sals
;
1400 current_source_location
*loc
1401 = get_source_location (current_program_space
);
1402 curr_sal
.symtab
= loc
->symtab
;
1403 curr_sal
.pspace
= current_program_space
;
1404 if (last_line_listed
!= 0)
1405 curr_sal
.line
= last_line_listed
;
1407 curr_sal
.line
= loc
->line
;
1413 decoded_sals
= decode_line_with_last_displayed (arg
,
1414 DECODE_LINE_LIST_MODE
);
1415 sals
= decoded_sals
;
1420 /* C++ More than one line may have been specified, as when the user
1421 specifies an overloaded function name. Print info on them all. */
1422 for (const auto &sal
: sals
)
1424 if (sal
.pspace
!= current_program_space
)
1427 if (sal
.symtab
== 0)
1429 struct gdbarch
*gdbarch
= get_current_arch ();
1431 printf_filtered (_("No line number information available"));
1434 /* This is useful for "info line *0x7f34". If we can't tell the
1435 user about a source line, at least let them have the symbolic
1437 printf_filtered (" for address ");
1439 print_address (gdbarch
, sal
.pc
, gdb_stdout
);
1442 printf_filtered (".");
1443 printf_filtered ("\n");
1445 else if (sal
.line
> 0
1446 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
1448 struct gdbarch
*gdbarch
1449 = get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
1451 if (start_pc
== end_pc
)
1453 printf_filtered ("Line %d of \"%s\"",
1455 symtab_to_filename_for_display (sal
.symtab
));
1457 printf_filtered (" is at address ");
1458 print_address (gdbarch
, start_pc
, gdb_stdout
);
1460 printf_filtered (" but contains no code.\n");
1464 printf_filtered ("Line %d of \"%s\"",
1466 symtab_to_filename_for_display (sal
.symtab
));
1468 printf_filtered (" starts at address ");
1469 print_address (gdbarch
, start_pc
, gdb_stdout
);
1471 printf_filtered (" and ends at ");
1472 print_address (gdbarch
, end_pc
, gdb_stdout
);
1473 printf_filtered (".\n");
1476 /* x/i should display this line's code. */
1477 set_next_address (gdbarch
, start_pc
);
1479 /* Repeating "info line" should do the following line. */
1480 last_line_listed
= sal
.line
+ 1;
1482 /* If this is the only line, show the source code. If it could
1483 not find the file, don't do anything special. */
1484 if (sals
.size () == 1)
1485 annotate_source_line (sal
.symtab
, sal
.line
, 0, start_pc
);
1488 /* Is there any case in which we get here, and have an address
1489 which the user would want to see? If we have debugging symbols
1490 and no line numbers? */
1491 printf_filtered (_("Line number %d is out of range for \"%s\".\n"),
1492 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
1496 /* Commands to search the source file for a regexp. */
1498 /* Helper for forward_search_command/reverse_search_command. FORWARD
1499 indicates direction: true for forward, false for
1500 backward/reverse. */
1503 search_command_helper (const char *regex
, int from_tty
, bool forward
)
1505 const char *msg
= re_comp (regex
);
1507 error (("%s"), msg
);
1509 current_source_location
*loc
1510 = get_source_location (current_program_space
);
1511 if (loc
->symtab
== nullptr)
1512 select_source_symtab (0);
1514 scoped_fd
desc (open_source_file (loc
->symtab
));
1515 if (desc
.get () < 0)
1516 perror_with_name (symtab_to_filename_for_display (loc
->symtab
));
1519 ? last_line_listed
+ 1
1520 : last_line_listed
- 1);
1522 const std::vector
<off_t
> *offsets
;
1524 || !g_source_cache
.get_line_charpos (loc
->symtab
, &offsets
)
1525 || line
> offsets
->size ())
1526 error (_("Expression not found"));
1528 if (lseek (desc
.get (), (*offsets
)[line
- 1], 0) < 0)
1529 perror_with_name (symtab_to_filename_for_display (loc
->symtab
));
1531 gdb_file_up stream
= desc
.to_file (FDOPEN_MODE
);
1532 clearerr (stream
.get ());
1534 gdb::def_vector
<char> buf
;
1541 int c
= fgetc (stream
.get ());
1548 while (c
!= '\n' && (c
= fgetc (stream
.get ())) >= 0);
1550 /* Remove the \r, if any, at the end of the line, otherwise
1551 regular expressions that end with $ or \n won't work. */
1552 size_t sz
= buf
.size ();
1553 if (sz
>= 2 && buf
[sz
- 2] == '\r')
1556 buf
.resize (sz
- 1);
1559 /* We now have a source line in buf, null terminate and match. */
1560 buf
.push_back ('\0');
1561 if (re_exec (buf
.data ()) > 0)
1564 print_source_lines (loc
->symtab
, line
, line
+ 1, 0);
1565 set_internalvar_integer (lookup_internalvar ("_"), line
);
1566 loc
->line
= std::max (line
- lines_to_list
/ 2, 1);
1577 if (fseek (stream
.get (), (*offsets
)[line
- 1], 0) < 0)
1579 const char *filename
1580 = symtab_to_filename_for_display (loc
->symtab
);
1581 perror_with_name (filename
);
1586 printf_filtered (_("Expression not found\n"));
1590 forward_search_command (const char *regex
, int from_tty
)
1592 search_command_helper (regex
, from_tty
, true);
1596 reverse_search_command (const char *regex
, int from_tty
)
1598 search_command_helper (regex
, from_tty
, false);
1601 /* If the last character of PATH is a directory separator, then strip it. */
1604 strip_trailing_directory_separator (char *path
)
1606 const int last
= strlen (path
) - 1;
1609 return; /* No stripping is needed if PATH is the empty string. */
1611 if (IS_DIR_SEPARATOR (path
[last
]))
1615 /* Return the path substitution rule that matches FROM.
1616 Return NULL if no rule matches. */
1618 static struct substitute_path_rule
*
1619 find_substitute_path_rule (const char *from
)
1621 struct substitute_path_rule
*rule
= substitute_path_rules
;
1623 while (rule
!= NULL
)
1625 if (FILENAME_CMP (rule
->from
, from
) == 0)
1633 /* Add a new substitute-path rule at the end of the current list of rules.
1634 The new rule will replace FROM into TO. */
1637 add_substitute_path_rule (char *from
, char *to
)
1639 struct substitute_path_rule
*rule
;
1640 struct substitute_path_rule
*new_rule
= XNEW (struct substitute_path_rule
);
1642 new_rule
->from
= xstrdup (from
);
1643 new_rule
->to
= xstrdup (to
);
1644 new_rule
->next
= NULL
;
1646 /* If the list of rules are empty, then insert the new rule
1647 at the head of the list. */
1649 if (substitute_path_rules
== NULL
)
1651 substitute_path_rules
= new_rule
;
1655 /* Otherwise, skip to the last rule in our list and then append
1658 rule
= substitute_path_rules
;
1659 while (rule
->next
!= NULL
)
1662 rule
->next
= new_rule
;
1665 /* Remove the given source path substitution rule from the current list
1666 of rules. The memory allocated for that rule is also deallocated. */
1669 delete_substitute_path_rule (struct substitute_path_rule
*rule
)
1671 if (rule
== substitute_path_rules
)
1672 substitute_path_rules
= rule
->next
;
1675 struct substitute_path_rule
*prev
= substitute_path_rules
;
1677 while (prev
!= NULL
&& prev
->next
!= rule
)
1680 gdb_assert (prev
!= NULL
);
1682 prev
->next
= rule
->next
;
1690 /* Implement the "show substitute-path" command. */
1693 show_substitute_path_command (const char *args
, int from_tty
)
1695 struct substitute_path_rule
*rule
= substitute_path_rules
;
1698 gdb_argv
argv (args
);
1700 /* We expect zero or one argument. */
1702 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1703 error (_("Too many arguments in command"));
1705 if (argv
!= NULL
&& argv
[0] != NULL
)
1708 /* Print the substitution rules. */
1712 (_("Source path substitution rule matching `%s':\n"), from
);
1714 printf_filtered (_("List of all source path substitution rules:\n"));
1716 while (rule
!= NULL
)
1718 if (from
== NULL
|| substitute_path_rule_matches (rule
, from
) != 0)
1719 printf_filtered (" `%s' -> `%s'.\n", rule
->from
, rule
->to
);
1724 /* Implement the "unset substitute-path" command. */
1727 unset_substitute_path_command (const char *args
, int from_tty
)
1729 struct substitute_path_rule
*rule
= substitute_path_rules
;
1730 gdb_argv
argv (args
);
1734 /* This function takes either 0 or 1 argument. */
1736 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1737 error (_("Incorrect usage, too many arguments in command"));
1739 if (argv
!= NULL
&& argv
[0] != NULL
)
1742 /* If the user asked for all the rules to be deleted, ask him
1743 to confirm and give him a chance to abort before the action
1747 && !query (_("Delete all source path substitution rules? ")))
1748 error (_("Canceled"));
1750 /* Delete the rule matching the argument. No argument means that
1751 all rules should be deleted. */
1753 while (rule
!= NULL
)
1755 struct substitute_path_rule
*next
= rule
->next
;
1757 if (from
== NULL
|| FILENAME_CMP (from
, rule
->from
) == 0)
1759 delete_substitute_path_rule (rule
);
1766 /* If the user asked for a specific rule to be deleted but
1767 we could not find it, then report an error. */
1769 if (from
!= NULL
&& !rule_found
)
1770 error (_("No substitution rule defined for `%s'"), from
);
1772 forget_cached_source_info ();
1775 /* Add a new source path substitution rule. */
1778 set_substitute_path_command (const char *args
, int from_tty
)
1780 struct substitute_path_rule
*rule
;
1782 gdb_argv
argv (args
);
1784 if (argv
== NULL
|| argv
[0] == NULL
|| argv
[1] == NULL
)
1785 error (_("Incorrect usage, too few arguments in command"));
1787 if (argv
[2] != NULL
)
1788 error (_("Incorrect usage, too many arguments in command"));
1790 if (*(argv
[0]) == '\0')
1791 error (_("First argument must be at least one character long"));
1793 /* Strip any trailing directory separator character in either FROM
1794 or TO. The substitution rule already implicitly contains them. */
1795 strip_trailing_directory_separator (argv
[0]);
1796 strip_trailing_directory_separator (argv
[1]);
1798 /* If a rule with the same "from" was previously defined, then
1799 delete it. This new rule replaces it. */
1801 rule
= find_substitute_path_rule (argv
[0]);
1803 delete_substitute_path_rule (rule
);
1805 /* Insert the new substitution rule. */
1807 add_substitute_path_rule (argv
[0], argv
[1]);
1808 forget_cached_source_info ();
1813 source_lines_range::source_lines_range (int startline
,
1814 source_lines_range::direction dir
)
1816 if (dir
== source_lines_range::FORWARD
)
1818 LONGEST end
= static_cast <LONGEST
> (startline
) + get_lines_to_list ();
1823 m_startline
= startline
;
1824 m_stopline
= static_cast <int> (end
);
1828 LONGEST start
= static_cast <LONGEST
> (startline
) - get_lines_to_list ();
1833 m_startline
= static_cast <int> (start
);
1834 m_stopline
= startline
;
1840 _initialize_source (void)
1842 struct cmd_list_element
*c
;
1844 init_source_path ();
1846 /* The intention is to use POSIX Basic Regular Expressions.
1847 Always use the GNU regex routine for consistency across all hosts.
1848 Our current GNU regex.c does not have all the POSIX features, so this is
1849 just an approximation. */
1850 re_set_syntax (RE_SYNTAX_GREP
);
1852 c
= add_cmd ("directory", class_files
, directory_command
, _("\
1853 Add directory DIR to beginning of search path for source files.\n\
1854 Forget cached info on source file locations and line positions.\n\
1855 DIR can also be $cwd for the current working directory, or $cdir for the\n\
1856 directory in which the source file was compiled into object code.\n\
1857 With no argument, reset the search path to $cdir:$cwd, the default."),
1861 add_com_alias ("use", "directory", class_files
, 0);
1863 set_cmd_completer (c
, filename_completer
);
1865 add_setshow_optional_filename_cmd ("directories",
1869 Set the search path for finding source files."),
1871 Show the search path for finding source files."),
1873 $cwd in the path means the current working directory.\n\
1874 $cdir in the path means the compilation directory of the source file.\n\
1875 GDB ensures the search path always ends with $cdir:$cwd by\n\
1876 appending these directories if necessary.\n\
1877 Setting the value to an empty string sets it to $cdir:$cwd, the default."),
1878 set_directories_command
,
1879 show_directories_command
,
1880 &setlist
, &showlist
);
1882 add_info ("source", info_source_command
,
1883 _("Information about the current source file."));
1885 add_info ("line", info_line_command
, _("\
1886 Core addresses of the code for a source line.\n\
1887 Line can be specified as\n\
1888 LINENUM, to list around that line in current file,\n\
1889 FILE:LINENUM, to list around that line in that file,\n\
1890 FUNCTION, to list around beginning of that function,\n\
1891 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1892 Default is to describe the last source line that was listed.\n\n\
1893 This sets the default address for \"x\" to the line's first instruction\n\
1894 so that \"x/i\" suffices to start examining the machine code.\n\
1895 The address is also stored as the value of \"$_\"."));
1897 add_com ("forward-search", class_files
, forward_search_command
, _("\
1898 Search for regular expression (see regex(3)) from last line listed.\n\
1899 The matching line number is also stored as the value of \"$_\"."));
1900 add_com_alias ("search", "forward-search", class_files
, 0);
1901 add_com_alias ("fo", "forward-search", class_files
, 1);
1903 add_com ("reverse-search", class_files
, reverse_search_command
, _("\
1904 Search backward for regular expression (see regex(3)) from last line listed.\n\
1905 The matching line number is also stored as the value of \"$_\"."));
1906 add_com_alias ("rev", "reverse-search", class_files
, 1);
1908 add_setshow_integer_cmd ("listsize", class_support
, &lines_to_list
, _("\
1909 Set number of source lines gdb will list by default."), _("\
1910 Show number of source lines gdb will list by default."), _("\
1911 Use this to choose how many source lines the \"list\" displays (unless\n\
1912 the \"list\" argument explicitly specifies some other number).\n\
1913 A value of \"unlimited\", or zero, means there's no limit."),
1916 &setlist
, &showlist
);
1918 add_cmd ("substitute-path", class_files
, set_substitute_path_command
,
1920 Add a substitution rule to rewrite the source directories.\n\
1921 Usage: set substitute-path FROM TO\n\
1922 The rule is applied only if the directory name starts with FROM\n\
1923 directly followed by a directory separator.\n\
1924 If a substitution rule was previously set for FROM, the old rule\n\
1925 is replaced by the new one."),
1928 add_cmd ("substitute-path", class_files
, unset_substitute_path_command
,
1930 Delete one or all substitution rules rewriting the source directories.\n\
1931 Usage: unset substitute-path [FROM]\n\
1932 Delete the rule for substituting FROM in source directories. If FROM\n\
1933 is not specified, all substituting rules are deleted.\n\
1934 If the debugger cannot find a rule for FROM, it will display a warning."),
1937 add_cmd ("substitute-path", class_files
, show_substitute_path_command
,
1939 Show one or all substitution rules rewriting the source directories.\n\
1940 Usage: show substitute-path [FROM]\n\
1941 Print the rule for substituting FROM in source directories. If FROM\n\
1942 is not specified, print all substitution rules."),
1945 add_setshow_enum_cmd ("filename-display", class_files
,
1946 filename_display_kind_names
,
1947 &filename_display_string
, _("\
1948 Set how to display filenames."), _("\
1949 Show how to display filenames."), _("\
1950 filename-display can be:\n\
1951 basename - display only basename of a filename\n\
1952 relative - display a filename relative to the compilation directory\n\
1953 absolute - display an absolute filename\n\
1954 By default, relative filenames are displayed."),
1956 show_filename_display_string
,
1957 &setlist
, &showlist
);