1 /* List lines of source files for GDB, the GNU debugger.
2 Copyright (C) 1986-2021 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/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"
54 #define OPEN_MODE (O_RDONLY | O_BINARY)
55 #define FDOPEN_MODE FOPEN_RB
57 /* Path of directories to search for source files.
58 Same format as the PATH environment variable's value. */
62 /* Support for source path substitution commands. */
64 struct substitute_path_rule
68 struct substitute_path_rule
*next
;
71 static struct substitute_path_rule
*substitute_path_rules
= NULL
;
73 /* An instance of this is attached to each program space. */
75 struct current_source_location
79 current_source_location () = default;
82 void set (struct symtab
*s
, int l
)
86 gdb::observers::current_source_symtab_and_line_changed
.notify ();
90 struct symtab
*symtab () const
95 /* Get the line number. */
103 /* Symtab of default file for listing lines of. */
105 struct symtab
*m_symtab
= nullptr;
107 /* Default next line to list. */
112 static program_space_key
<current_source_location
> current_source_key
;
114 /* Default number of lines to print with commands like "list".
115 This is based on guessing how many long (i.e. more than chars_per_line
116 characters) lines there will be. To be completely correct, "list"
117 and friends should be rewritten to count characters and see where
118 things are wrapping, but that would be a fair amount of work. */
120 static int lines_to_list
= 10;
122 show_lines_to_list (struct ui_file
*file
, int from_tty
,
123 struct cmd_list_element
*c
, const char *value
)
125 fprintf_filtered (file
,
126 _("Number of source lines gdb "
127 "will list by default is %s.\n"),
131 /* Possible values of 'set filename-display'. */
132 static const char filename_display_basename
[] = "basename";
133 static const char filename_display_relative
[] = "relative";
134 static const char filename_display_absolute
[] = "absolute";
136 static const char *const filename_display_kind_names
[] = {
137 filename_display_basename
,
138 filename_display_relative
,
139 filename_display_absolute
,
143 static const char *filename_display_string
= filename_display_relative
;
146 show_filename_display_string (struct ui_file
*file
, int from_tty
,
147 struct cmd_list_element
*c
, const char *value
)
149 fprintf_filtered (file
, _("Filenames are displayed as \"%s\".\n"), value
);
152 /* When true GDB will stat and open source files as required, but when
153 false, GDB will avoid accessing source files as much as possible. */
155 static bool source_open
= true;
157 /* Implement 'show source open'. */
160 show_source_open (struct ui_file
*file
, int from_tty
,
161 struct cmd_list_element
*c
, const char *value
)
163 fprintf_filtered (file
, _("Source opening is \"%s\".\n"), value
);
166 /* Line number of last line printed. Default for various commands.
167 current_source_line is usually, but not always, the same as this. */
169 static int last_line_listed
;
171 /* First line number listed by last listing command. If 0, then no
172 source lines have yet been listed since the last time the current
173 source line was changed. */
175 static int first_line_listed
;
177 /* Saves the name of the last source file visited and a possible error code.
178 Used to prevent repeating annoying "No such file or directories" msgs. */
180 static struct symtab
*last_source_visited
= NULL
;
181 static bool last_source_error
= false;
183 /* Return the first line listed by print_source_lines.
184 Used by command interpreters to request listing from
188 get_first_line_listed (void)
190 return first_line_listed
;
193 /* Clear line listed range. This makes the next "list" center the
194 printed source lines around the current source line. */
197 clear_lines_listed_range (void)
199 first_line_listed
= 0;
200 last_line_listed
= 0;
203 /* Return the default number of lines to print with commands like the
204 cli "list". The caller of print_source_lines must use this to
205 calculate the end line and use it in the call to print_source_lines
206 as it does not automatically use this value. */
209 get_lines_to_list (void)
211 return lines_to_list
;
214 /* A helper to return the current source location object for PSPACE,
215 creating it if it does not exist. */
217 static current_source_location
*
218 get_source_location (program_space
*pspace
)
220 current_source_location
*loc
221 = current_source_key
.get (pspace
);
223 loc
= current_source_key
.emplace (pspace
);
227 /* Return the current source file for listing and next line to list.
228 NOTE: The returned sal pc and end fields are not valid. */
230 struct symtab_and_line
231 get_current_source_symtab_and_line (void)
233 symtab_and_line cursal
;
234 current_source_location
*loc
= get_source_location (current_program_space
);
236 cursal
.pspace
= current_program_space
;
237 cursal
.symtab
= loc
->symtab ();
238 cursal
.line
= loc
->line ();
245 /* If the current source file for listing is not set, try and get a default.
246 Usually called before get_current_source_symtab_and_line() is called.
247 It may err out if a default cannot be determined.
248 We must be cautious about where it is called, as it can recurse as the
249 process of determining a new default may call the caller!
250 Use get_current_source_symtab_and_line only to get whatever
251 we have without erroring out or trying to get a default. */
254 set_default_source_symtab_and_line (void)
256 if (!have_full_symbols () && !have_partial_symbols ())
257 error (_("No symbol table is loaded. Use the \"file\" command."));
259 /* Pull in a current source symtab if necessary. */
260 current_source_location
*loc
= get_source_location (current_program_space
);
261 if (loc
->symtab () == nullptr)
262 select_source_symtab (0);
265 /* Return the current default file for listing and next line to list
266 (the returned sal pc and end fields are not valid.)
267 and set the current default to whatever is in SAL.
268 NOTE: The returned sal pc and end fields are not valid. */
270 struct symtab_and_line
271 set_current_source_symtab_and_line (const symtab_and_line
&sal
)
273 symtab_and_line cursal
;
275 current_source_location
*loc
= get_source_location (sal
.pspace
);
277 cursal
.pspace
= sal
.pspace
;
278 cursal
.symtab
= loc
->symtab ();
279 cursal
.line
= loc
->line ();
283 loc
->set (sal
.symtab
, sal
.line
);
285 /* Force the next "list" to center around the current line. */
286 clear_lines_listed_range ();
291 /* Reset any information stored about a default file and line to print. */
294 clear_current_source_symtab_and_line (void)
296 current_source_location
*loc
= get_source_location (current_program_space
);
297 loc
->set (nullptr, 0);
303 select_source_symtab (struct symtab
*s
)
307 current_source_location
*loc
308 = get_source_location (SYMTAB_PSPACE (s
));
313 current_source_location
*loc
= get_source_location (current_program_space
);
314 if (loc
->symtab () != nullptr)
317 /* Make the default place to list be the function `main'
319 block_symbol bsym
= lookup_symbol (main_name (), 0, VAR_DOMAIN
, 0);
320 if (bsym
.symbol
!= nullptr && SYMBOL_CLASS (bsym
.symbol
) == LOC_BLOCK
)
322 symtab_and_line sal
= find_function_start_sal (bsym
.symbol
, true);
323 if (sal
.symtab
== NULL
)
324 /* We couldn't find the location of `main', possibly due to missing
325 line number info, fall back to line 1 in the corresponding file. */
326 loc
->set (symbol_symtab (bsym
.symbol
), 1);
328 loc
->set (sal
.symtab
, std::max (sal
.line
- (lines_to_list
- 1), 1));
332 /* Alright; find the last file in the symtab list (ignoring .h's
333 and namespace symtabs). */
335 struct symtab
*new_symtab
= nullptr;
337 for (objfile
*ofp
: current_program_space
->objfiles ())
339 for (compunit_symtab
*cu
: ofp
->compunits ())
341 for (symtab
*symtab
: compunit_filetabs (cu
))
343 const char *name
= symtab
->filename
;
344 int len
= strlen (name
);
346 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
347 || strcmp (name
, "<<C++-namespaces>>") == 0)))
353 loc
->set (new_symtab
, 1);
354 if (new_symtab
!= nullptr)
357 for (objfile
*objfile
: current_program_space
->objfiles ())
359 s
= objfile
->find_last_source_symtab ();
363 if (new_symtab
!= nullptr)
365 loc
->set (new_symtab
,1);
369 error (_("Can't find a default source file"));
372 /* Handler for "set directories path-list" command.
373 "set dir mumble" doesn't prepend paths, it resets the entire
374 path list. The theory is that set(show(dir)) should be a no-op. */
377 set_directories_command (const char *args
,
378 int from_tty
, struct cmd_list_element
*c
)
380 /* This is the value that was set.
381 It needs to be processed to maintain $cdir:$cwd and remove dups. */
382 char *set_path
= source_path
;
384 /* We preserve the invariant that $cdir:$cwd begins life at the end of
385 the list by calling init_source_path. If they appear earlier in
386 SET_PATH then mod_path will move them appropriately.
387 mod_path will also remove duplicates. */
389 if (*set_path
!= '\0')
390 mod_path (set_path
, &source_path
);
395 /* Print the list of source directories.
396 This is used by the "ld" command, so it has the signature of a command
400 show_directories_1 (char *ignore
, int from_tty
)
402 puts_filtered ("Source directories searched: ");
403 puts_filtered (source_path
);
404 puts_filtered ("\n");
407 /* Handler for "show directories" command. */
410 show_directories_command (struct ui_file
*file
, int from_tty
,
411 struct cmd_list_element
*c
, const char *value
)
413 show_directories_1 (NULL
, from_tty
);
419 forget_cached_source_info_for_objfile (struct objfile
*objfile
)
421 for (compunit_symtab
*cu
: objfile
->compunits ())
423 for (symtab
*s
: compunit_filetabs (cu
))
425 if (s
->fullname
!= NULL
)
433 objfile
->forget_cached_source_info ();
439 forget_cached_source_info (void)
441 for (struct program_space
*pspace
: program_spaces
)
442 for (objfile
*objfile
: pspace
->objfiles ())
444 forget_cached_source_info_for_objfile (objfile
);
447 g_source_cache
.clear ();
448 last_source_visited
= NULL
;
452 init_source_path (void)
456 xsnprintf (buf
, sizeof (buf
), "$cdir%c$cwd", DIRNAME_SEPARATOR
);
457 source_path
= xstrdup (buf
);
458 forget_cached_source_info ();
461 /* Add zero or more directories to the front of the source path. */
464 directory_command (const char *dirname
, int from_tty
)
466 bool value_changed
= false;
468 /* FIXME, this goes to "delete dir"... */
471 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", source_path
);
488 show_directories_1 ((char *) 0, from_tty
);
492 /* Add a path given with the -d command line switch.
493 This will not be quoted so we must not treat spaces as separators. */
496 directory_switch (const char *dirname
, int from_tty
)
498 add_path (dirname
, &source_path
, 0);
501 /* Add zero or more directories to the front of an arbitrary path. */
504 mod_path (const char *dirname
, char **which_path
)
506 add_path (dirname
, which_path
, 1);
509 /* Workhorse of mod_path. Takes an extra argument to determine
510 if dirname should be parsed for separators that indicate multiple
511 directories. This allows for interfaces that pre-parse the dirname
512 and allow specification of traditional separator characters such
516 add_path (const char *dirname
, char **which_path
, int parse_separators
)
518 char *old
= *which_path
;
520 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
;
525 if (parse_separators
)
527 /* This will properly parse the space and tab separators
528 and any quotes that may exist. */
529 gdb_argv
argv (dirname
);
531 for (char *arg
: argv
)
532 dirnames_to_char_ptr_vec_append (&dir_vec
, arg
);
535 dir_vec
.emplace_back (xstrdup (dirname
));
537 for (const gdb::unique_xmalloc_ptr
<char> &name_up
: dir_vec
)
539 char *name
= name_up
.get ();
542 gdb::unique_xmalloc_ptr
<char> new_name_holder
;
544 /* Spaces and tabs will have been removed by buildargv().
545 NAME is the start of the directory.
546 P is the '\0' following the end. */
547 p
= name
+ strlen (name
);
549 while (!(IS_DIR_SEPARATOR (*name
) && p
<= name
+ 1) /* "/" */
550 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
551 /* On MS-DOS and MS-Windows, h:\ is different from h: */
552 && !(p
== name
+ 3 && name
[1] == ':') /* "d:/" */
555 && IS_DIR_SEPARATOR (p
[-1]))
556 /* Sigh. "foo/" => "foo" */
560 while (p
> name
&& p
[-1] == '.')
564 /* "." => getwd (). */
565 name
= current_directory
;
568 else if (p
> name
+ 1 && IS_DIR_SEPARATOR (p
[-2]))
578 /* "...foo/." => "...foo". */
591 new_name_holder
.reset (tilde_expand (name
));
592 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
593 else if (IS_ABSOLUTE_PATH (name
) && p
== name
+ 2) /* "d:" => "d:." */
594 new_name_holder
.reset (concat (name
, ".", (char *) NULL
));
596 else if (!IS_ABSOLUTE_PATH (name
) && name
[0] != '$')
597 new_name_holder
= gdb_abspath (name
);
599 new_name_holder
.reset (savestring (name
, p
- name
));
600 name
= new_name_holder
.get ();
602 /* Unless it's a variable, check existence. */
605 /* These are warnings, not errors, since we don't want a
606 non-existent directory in a .gdbinit file to stop processing
607 of the .gdbinit file.
609 Whether they get added to the path is more debatable. Current
610 answer is yes, in case the user wants to go make the directory
611 or whatever. If the directory continues to not exist/not be
612 a directory/etc, then having them in the path should be
614 if (stat (name
, &st
) < 0)
616 int save_errno
= errno
;
618 fprintf_unfiltered (gdb_stderr
, "Warning: ");
619 print_sys_errmsg (name
, save_errno
);
621 else if ((st
.st_mode
& S_IFMT
) != S_IFDIR
)
622 warning (_("%s is not a directory."), name
);
627 unsigned int len
= strlen (name
);
633 /* FIXME: we should use realpath() or its work-alike
634 before comparing. Then all the code above which
635 removes excess slashes and dots could simply go away. */
636 if (!filename_ncmp (p
, name
, len
)
637 && (p
[len
] == '\0' || p
[len
] == DIRNAME_SEPARATOR
))
639 /* Found it in the search path, remove old copy. */
642 /* Back over leading separator. */
645 if (prefix
> p
- *which_path
)
647 /* Same dir twice in one cmd. */
650 /* Copy from next '\0' or ':'. */
651 memmove (p
, &p
[len
+ 1], strlen (&p
[len
+ 1]) + 1);
653 p
= strchr (p
, DIRNAME_SEPARATOR
);
660 tinybuf
[0] = DIRNAME_SEPARATOR
;
663 /* If we have already tacked on a name(s) in this command,
664 be sure they stay on the front as we tack on some
672 temp
= concat (old
, tinybuf
, name
, (char *)NULL
);
674 *which_path
= concat (temp
, "", &old
[prefix
], (char *) NULL
);
675 prefix
= strlen (temp
);
680 *which_path
= concat (name
, (old
[0] ? tinybuf
: old
),
682 prefix
= strlen (name
);
694 info_source_command (const char *ignore
, int from_tty
)
696 current_source_location
*loc
697 = get_source_location (current_program_space
);
698 struct symtab
*s
= loc
->symtab ();
699 struct compunit_symtab
*cust
;
703 printf_filtered (_("No current source file.\n"));
707 cust
= SYMTAB_COMPUNIT (s
);
708 printf_filtered (_("Current source file is %s\n"), s
->filename
);
709 if (SYMTAB_DIRNAME (s
) != NULL
)
710 printf_filtered (_("Compilation directory is %s\n"), SYMTAB_DIRNAME (s
));
712 printf_filtered (_("Located in %s\n"), s
->fullname
);
713 const std::vector
<off_t
> *offsets
;
714 if (g_source_cache
.get_line_charpos (s
, &offsets
))
715 printf_filtered (_("Contains %d line%s.\n"), (int) offsets
->size (),
716 offsets
->size () == 1 ? "" : "s");
718 printf_filtered (_("Source language is %s.\n"), language_str (s
->language
));
719 printf_filtered (_("Producer is %s.\n"),
720 COMPUNIT_PRODUCER (cust
) != NULL
721 ? COMPUNIT_PRODUCER (cust
) : _("unknown"));
722 printf_filtered (_("Compiled with %s debugging format.\n"),
723 COMPUNIT_DEBUGFORMAT (cust
));
724 printf_filtered (_("%s preprocessor macro info.\n"),
725 COMPUNIT_MACRO_TABLE (cust
) != NULL
726 ? "Includes" : "Does not include");
730 /* Helper function to remove characters from the start of PATH so that
731 PATH can then be appended to a directory name. We remove leading drive
732 letters (for dos) as well as leading '/' characters and './'
736 prepare_path_for_appending (const char *path
)
738 /* For dos paths, d:/foo -> /foo, and d:foo -> foo. */
739 if (HAS_DRIVE_SPEC (path
))
740 path
= STRIP_DRIVE_SPEC (path
);
742 const char *old_path
;
747 /* /foo => foo, to avoid multiple slashes that Emacs doesn't like. */
748 while (IS_DIR_SEPARATOR(path
[0]))
752 while (path
[0] == '.' && IS_DIR_SEPARATOR (path
[1]))
755 while (old_path
!= path
);
760 /* Open a file named STRING, searching path PATH (dir names sep by some char)
761 using mode MODE in the calls to open. You cannot use this function to
762 create files (O_CREAT).
764 OPTS specifies the function behaviour in specific cases.
766 If OPF_TRY_CWD_FIRST, try to open ./STRING before searching PATH.
767 (ie pretend the first element of PATH is "."). This also indicates
768 that, unless OPF_SEARCH_IN_PATH is also specified, a slash in STRING
769 disables searching of the path (this is so that "exec-file ./foo" or
770 "symbol-file ./foo" insures that you get that particular version of
771 foo or an error message).
773 If OPTS has OPF_SEARCH_IN_PATH set, absolute names will also be
774 searched in path (we usually want this for source files but not for
777 If FILENAME_OPENED is non-null, set it to a newly allocated string naming
778 the actual file opened (this string will always start with a "/"). We
779 have to take special pains to avoid doubling the "/" between the directory
780 and the file, sigh! Emacs gets confuzzed by this when we print the
783 If OPTS has OPF_RETURN_REALPATH set return FILENAME_OPENED resolved by
784 gdb_realpath. Even without OPF_RETURN_REALPATH this function still returns
785 filename starting with "/". If FILENAME_OPENED is NULL this option has no
788 If a file is found, return the descriptor.
789 Otherwise, return -1, with errno set for the last name we tried to open. */
791 /* >>>> This should only allow files of certain types,
792 >>>> eg executable, non-directory. */
794 openp (const char *path
, openp_flags opts
, const char *string
,
795 int mode
, gdb::unique_xmalloc_ptr
<char> *filename_opened
)
800 /* The errno set for the last name we tried to open (and
803 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
;
805 /* The open syscall MODE parameter is not specified. */
806 gdb_assert ((mode
& O_CREAT
) == 0);
807 gdb_assert (string
!= NULL
);
809 /* A file with an empty name cannot possibly exist. Report a failure
810 without further checking.
812 This is an optimization which also defends us against buggy
813 implementations of the "stat" function. For instance, we have
814 noticed that a MinGW debugger built on Windows XP 32bits crashes
815 when the debugger is started with an empty argument. */
816 if (string
[0] == '\0')
827 if ((opts
& OPF_TRY_CWD_FIRST
) || IS_ABSOLUTE_PATH (string
))
829 int i
, reg_file_errno
;
831 if (is_regular_file (string
, ®_file_errno
))
833 filename
= (char *) alloca (strlen (string
) + 1);
834 strcpy (filename
, string
);
835 fd
= gdb_open_cloexec (filename
, mode
, 0);
844 last_errno
= reg_file_errno
;
847 if (!(opts
& OPF_SEARCH_IN_PATH
))
848 for (i
= 0; string
[i
]; i
++)
849 if (IS_DIR_SEPARATOR (string
[i
]))
853 /* Remove characters from the start of PATH that we don't need when PATH
854 is appended to a directory name. */
855 string
= prepare_path_for_appending (string
);
857 alloclen
= strlen (path
) + strlen (string
) + 2;
858 filename
= (char *) alloca (alloclen
);
862 dir_vec
= dirnames_to_char_ptr_vec (path
);
864 for (const gdb::unique_xmalloc_ptr
<char> &dir_up
: dir_vec
)
866 char *dir
= dir_up
.get ();
867 size_t len
= strlen (dir
);
870 if (strcmp (dir
, "$cwd") == 0)
872 /* Name is $cwd -- insert current directory name instead. */
875 /* First, realloc the filename buffer if too short. */
876 len
= strlen (current_directory
);
877 newlen
= len
+ strlen (string
) + 2;
878 if (newlen
> alloclen
)
881 filename
= (char *) alloca (alloclen
);
883 strcpy (filename
, current_directory
);
885 else if (strchr(dir
, '~'))
887 /* See whether we need to expand the tilde. */
890 gdb::unique_xmalloc_ptr
<char> tilde_expanded (tilde_expand (dir
));
892 /* First, realloc the filename buffer if too short. */
893 len
= strlen (tilde_expanded
.get ());
894 newlen
= len
+ strlen (string
) + 2;
895 if (newlen
> alloclen
)
898 filename
= (char *) alloca (alloclen
);
900 strcpy (filename
, tilde_expanded
.get ());
904 /* Normal file name in path -- just use it. */
905 strcpy (filename
, dir
);
907 /* Don't search $cdir. It's also a magic path like $cwd, but we
908 don't have enough information to expand it. The user *could*
909 have an actual directory named '$cdir' but handling that would
910 be confusing, it would mean different things in different
911 contexts. If the user really has '$cdir' one can use './$cdir'.
912 We can get $cdir when loading scripts. When loading source files
913 $cdir must have already been expanded to the correct value. */
914 if (strcmp (dir
, "$cdir") == 0)
918 /* Remove trailing slashes. */
919 while (len
> 0 && IS_DIR_SEPARATOR (filename
[len
- 1]))
922 strcat (filename
+ len
, SLASH_STRING
);
923 strcat (filename
, string
);
925 if (is_regular_file (filename
, ®_file_errno
))
927 fd
= gdb_open_cloexec (filename
, mode
, 0);
933 last_errno
= reg_file_errno
;
939 /* If a file was opened, canonicalize its filename. */
941 filename_opened
->reset (NULL
);
942 else if ((opts
& OPF_RETURN_REALPATH
) != 0)
943 *filename_opened
= gdb_realpath (filename
);
945 *filename_opened
= gdb_abspath (filename
);
953 /* This is essentially a convenience, for clients that want the behaviour
954 of openp, using source_path, but that really don't want the file to be
955 opened but want instead just to know what the full pathname is (as
956 qualified against source_path).
958 The current working directory is searched first.
960 If the file was found, this function returns 1, and FULL_PATHNAME is
961 set to the fully-qualified pathname.
963 Else, this functions returns 0, and FULL_PATHNAME is set to NULL. */
965 source_full_path_of (const char *filename
,
966 gdb::unique_xmalloc_ptr
<char> *full_pathname
)
970 fd
= openp (source_path
,
971 OPF_TRY_CWD_FIRST
| OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
,
972 filename
, O_RDONLY
, full_pathname
);
975 full_pathname
->reset (NULL
);
983 /* Return non-zero if RULE matches PATH, that is if the rule can be
987 substitute_path_rule_matches (const struct substitute_path_rule
*rule
,
990 const int from_len
= strlen (rule
->from
);
991 const int path_len
= strlen (path
);
993 if (path_len
< from_len
)
996 /* The substitution rules are anchored at the start of the path,
997 so the path should start with rule->from. */
999 if (filename_ncmp (path
, rule
->from
, from_len
) != 0)
1002 /* Make sure that the region in the path that matches the substitution
1003 rule is immediately followed by a directory separator (or the end of
1004 string character). */
1006 if (path
[from_len
] != '\0' && !IS_DIR_SEPARATOR (path
[from_len
]))
1012 /* Find the substitute-path rule that applies to PATH and return it.
1013 Return NULL if no rule applies. */
1015 static struct substitute_path_rule
*
1016 get_substitute_path_rule (const char *path
)
1018 struct substitute_path_rule
*rule
= substitute_path_rules
;
1020 while (rule
!= NULL
&& !substitute_path_rule_matches (rule
, path
))
1026 /* If the user specified a source path substitution rule that applies
1027 to PATH, then apply it and return the new path.
1029 Return NULL if no substitution rule was specified by the user,
1030 or if no rule applied to the given PATH. */
1032 gdb::unique_xmalloc_ptr
<char>
1033 rewrite_source_path (const char *path
)
1035 const struct substitute_path_rule
*rule
= get_substitute_path_rule (path
);
1042 from_len
= strlen (rule
->from
);
1044 /* Compute the rewritten path and return it. */
1047 (char *) xmalloc (strlen (path
) + 1 + strlen (rule
->to
) - from_len
);
1048 strcpy (new_path
, rule
->to
);
1049 strcat (new_path
, path
+ from_len
);
1051 return gdb::unique_xmalloc_ptr
<char> (new_path
);
1057 find_and_open_source (const char *filename
,
1058 const char *dirname
,
1059 gdb::unique_xmalloc_ptr
<char> *fullname
)
1061 char *path
= source_path
;
1065 /* If reading of source files is disabled then return a result indicating
1066 the attempt to read this source file failed. GDB will then display
1067 the filename and line number instead. */
1069 return scoped_fd (-1);
1071 /* Quick way out if we already know its full name. */
1074 /* The user may have requested that source paths be rewritten
1075 according to substitution rules he provided. If a substitution
1076 rule applies to this path, then apply it. */
1077 gdb::unique_xmalloc_ptr
<char> rewritten_fullname
1078 = rewrite_source_path (fullname
->get ());
1080 if (rewritten_fullname
!= NULL
)
1081 *fullname
= std::move (rewritten_fullname
);
1083 result
= gdb_open_cloexec (fullname
->get (), OPEN_MODE
, 0);
1087 *fullname
= gdb_realpath (fullname
->get ());
1088 return scoped_fd (result
);
1091 /* Didn't work -- free old one, try again. */
1092 fullname
->reset (NULL
);
1095 gdb::unique_xmalloc_ptr
<char> rewritten_dirname
;
1096 if (dirname
!= NULL
)
1098 /* If necessary, rewrite the compilation directory name according
1099 to the source path substitution rules specified by the user. */
1101 rewritten_dirname
= rewrite_source_path (dirname
);
1103 if (rewritten_dirname
!= NULL
)
1104 dirname
= rewritten_dirname
.get ();
1106 /* Replace a path entry of $cdir with the compilation directory
1109 p
= strstr (source_path
, "$cdir");
1110 if (p
&& (p
== path
|| p
[-1] == DIRNAME_SEPARATOR
)
1111 && (p
[cdir_len
] == DIRNAME_SEPARATOR
|| p
[cdir_len
] == '\0'))
1116 alloca (strlen (source_path
) + 1 + strlen (dirname
) + 1);
1117 len
= p
- source_path
;
1118 strncpy (path
, source_path
, len
); /* Before $cdir */
1119 strcpy (path
+ len
, dirname
); /* new stuff */
1120 strcat (path
+ len
, source_path
+ len
+ cdir_len
); /* After
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 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
= COMPUNIT_OBJFILE (SYMTAB_COMPUNIT (s
));
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 ");
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
));
1569 printf_filtered (" is at address ");
1570 print_address (gdbarch
, start_pc
, gdb_stdout
);
1572 printf_filtered (" but contains no code.\n");
1576 printf_filtered ("Line %d of \"%s\"",
1578 symtab_to_filename_for_display (sal
.symtab
));
1580 printf_filtered (" starts at address ");
1581 print_address (gdbarch
, start_pc
, gdb_stdout
);
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 /* Return the path substitution rule that matches FROM.
1731 Return NULL if no rule matches. */
1733 static struct substitute_path_rule
*
1734 find_substitute_path_rule (const char *from
)
1736 struct substitute_path_rule
*rule
= substitute_path_rules
;
1738 while (rule
!= NULL
)
1740 if (FILENAME_CMP (rule
->from
, from
) == 0)
1748 /* Add a new substitute-path rule at the end of the current list of rules.
1749 The new rule will replace FROM into TO. */
1752 add_substitute_path_rule (char *from
, char *to
)
1754 struct substitute_path_rule
*rule
;
1755 struct substitute_path_rule
*new_rule
= XNEW (struct substitute_path_rule
);
1757 new_rule
->from
= xstrdup (from
);
1758 new_rule
->to
= xstrdup (to
);
1759 new_rule
->next
= NULL
;
1761 /* If the list of rules are empty, then insert the new rule
1762 at the head of the list. */
1764 if (substitute_path_rules
== NULL
)
1766 substitute_path_rules
= new_rule
;
1770 /* Otherwise, skip to the last rule in our list and then append
1773 rule
= substitute_path_rules
;
1774 while (rule
->next
!= NULL
)
1777 rule
->next
= new_rule
;
1780 /* Remove the given source path substitution rule from the current list
1781 of rules. The memory allocated for that rule is also deallocated. */
1784 delete_substitute_path_rule (struct substitute_path_rule
*rule
)
1786 if (rule
== substitute_path_rules
)
1787 substitute_path_rules
= rule
->next
;
1790 struct substitute_path_rule
*prev
= substitute_path_rules
;
1792 while (prev
!= NULL
&& prev
->next
!= rule
)
1795 gdb_assert (prev
!= NULL
);
1797 prev
->next
= rule
->next
;
1805 /* Implement the "show substitute-path" command. */
1808 show_substitute_path_command (const char *args
, int from_tty
)
1810 struct substitute_path_rule
*rule
= substitute_path_rules
;
1813 gdb_argv
argv (args
);
1815 /* We expect zero or one argument. */
1817 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1818 error (_("Too many arguments in command"));
1820 if (argv
!= NULL
&& argv
[0] != NULL
)
1823 /* Print the substitution rules. */
1827 (_("Source path substitution rule matching `%s':\n"), from
);
1829 printf_filtered (_("List of all source path substitution rules:\n"));
1831 while (rule
!= NULL
)
1833 if (from
== NULL
|| substitute_path_rule_matches (rule
, from
) != 0)
1834 printf_filtered (" `%s' -> `%s'.\n", rule
->from
, rule
->to
);
1839 /* Implement the "unset substitute-path" command. */
1842 unset_substitute_path_command (const char *args
, int from_tty
)
1844 struct substitute_path_rule
*rule
= substitute_path_rules
;
1845 gdb_argv
argv (args
);
1849 /* This function takes either 0 or 1 argument. */
1851 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1852 error (_("Incorrect usage, too many arguments in command"));
1854 if (argv
!= NULL
&& argv
[0] != NULL
)
1857 /* If the user asked for all the rules to be deleted, ask him
1858 to confirm and give him a chance to abort before the action
1862 && !query (_("Delete all source path substitution rules? ")))
1863 error (_("Canceled"));
1865 /* Delete the rule matching the argument. No argument means that
1866 all rules should be deleted. */
1868 while (rule
!= NULL
)
1870 struct substitute_path_rule
*next
= rule
->next
;
1872 if (from
== NULL
|| FILENAME_CMP (from
, rule
->from
) == 0)
1874 delete_substitute_path_rule (rule
);
1881 /* If the user asked for a specific rule to be deleted but
1882 we could not find it, then report an error. */
1884 if (from
!= NULL
&& !rule_found
)
1885 error (_("No substitution rule defined for `%s'"), from
);
1887 forget_cached_source_info ();
1890 /* Add a new source path substitution rule. */
1893 set_substitute_path_command (const char *args
, int from_tty
)
1895 struct substitute_path_rule
*rule
;
1897 gdb_argv
argv (args
);
1899 if (argv
== NULL
|| argv
[0] == NULL
|| argv
[1] == NULL
)
1900 error (_("Incorrect usage, too few arguments in command"));
1902 if (argv
[2] != NULL
)
1903 error (_("Incorrect usage, too many arguments in command"));
1905 if (*(argv
[0]) == '\0')
1906 error (_("First argument must be at least one character long"));
1908 /* Strip any trailing directory separator character in either FROM
1909 or TO. The substitution rule already implicitly contains them. */
1910 strip_trailing_directory_separator (argv
[0]);
1911 strip_trailing_directory_separator (argv
[1]);
1913 /* If a rule with the same "from" was previously defined, then
1914 delete it. This new rule replaces it. */
1916 rule
= find_substitute_path_rule (argv
[0]);
1918 delete_substitute_path_rule (rule
);
1920 /* Insert the new substitution rule. */
1922 add_substitute_path_rule (argv
[0], argv
[1]);
1923 forget_cached_source_info ();
1928 source_lines_range::source_lines_range (int startline
,
1929 source_lines_range::direction dir
)
1931 if (dir
== source_lines_range::FORWARD
)
1933 LONGEST end
= static_cast <LONGEST
> (startline
) + get_lines_to_list ();
1938 m_startline
= startline
;
1939 m_stopline
= static_cast <int> (end
);
1943 LONGEST start
= static_cast <LONGEST
> (startline
) - get_lines_to_list ();
1948 m_startline
= static_cast <int> (start
);
1949 m_stopline
= startline
;
1953 /* Handle the "set source" base command. */
1956 set_source (const char *arg
, int from_tty
)
1958 help_list (setsourcelist
, "set source ", all_commands
, gdb_stdout
);
1961 /* Handle the "show source" base command. */
1964 show_source (const char *args
, int from_tty
)
1966 help_list (showsourcelist
, "show source ", all_commands
, gdb_stdout
);
1970 void _initialize_source ();
1972 _initialize_source ()
1974 init_source_path ();
1976 /* The intention is to use POSIX Basic Regular Expressions.
1977 Always use the GNU regex routine for consistency across all hosts.
1978 Our current GNU regex.c does not have all the POSIX features, so this is
1979 just an approximation. */
1980 re_set_syntax (RE_SYNTAX_GREP
);
1982 cmd_list_element
*directory_cmd
1983 = add_cmd ("directory", class_files
, directory_command
, _("\
1984 Add directory DIR to beginning of search path for source files.\n\
1985 Forget cached info on source file locations and line positions.\n\
1986 DIR can also be $cwd for the current working directory, or $cdir for the\n\
1987 directory in which the source file was compiled into object code.\n\
1988 With no argument, reset the search path to $cdir:$cwd, the default."),
1992 add_com_alias ("use", directory_cmd
, class_files
, 0);
1994 set_cmd_completer (directory_cmd
, filename_completer
);
1996 add_setshow_optional_filename_cmd ("directories",
2000 Set the search path for finding source files."),
2002 Show the search path for finding source files."),
2004 $cwd in the path means the current working directory.\n\
2005 $cdir in the path means the compilation directory of the source file.\n\
2006 GDB ensures the search path always ends with $cdir:$cwd by\n\
2007 appending these directories if necessary.\n\
2008 Setting the value to an empty string sets it to $cdir:$cwd, the default."),
2009 set_directories_command
,
2010 show_directories_command
,
2011 &setlist
, &showlist
);
2013 add_info ("source", info_source_command
,
2014 _("Information about the current source file."));
2016 add_info ("line", info_line_command
, _("\
2017 Core addresses of the code for a source line.\n\
2018 Line can be specified as\n\
2019 LINENUM, to list around that line in current file,\n\
2020 FILE:LINENUM, to list around that line in that file,\n\
2021 FUNCTION, to list around beginning of that function,\n\
2022 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2023 Default is to describe the last source line that was listed.\n\n\
2024 This sets the default address for \"x\" to the line's first instruction\n\
2025 so that \"x/i\" suffices to start examining the machine code.\n\
2026 The address is also stored as the value of \"$_\"."));
2028 cmd_list_element
*forward_search_cmd
2029 = add_com ("forward-search", class_files
, forward_search_command
, _("\
2030 Search for regular expression (see regex(3)) from last line listed.\n\
2031 The matching line number is also stored as the value of \"$_\"."));
2032 add_com_alias ("search", forward_search_cmd
, class_files
, 0);
2033 add_com_alias ("fo", forward_search_cmd
, class_files
, 1);
2035 cmd_list_element
*reverse_search_cmd
2036 = add_com ("reverse-search", class_files
, reverse_search_command
, _("\
2037 Search backward for regular expression (see regex(3)) from last line listed.\n\
2038 The matching line number is also stored as the value of \"$_\"."));
2039 add_com_alias ("rev", reverse_search_cmd
, class_files
, 1);
2041 add_setshow_integer_cmd ("listsize", class_support
, &lines_to_list
, _("\
2042 Set number of source lines gdb will list by default."), _("\
2043 Show number of source lines gdb will list by default."), _("\
2044 Use this to choose how many source lines the \"list\" displays (unless\n\
2045 the \"list\" argument explicitly specifies some other number).\n\
2046 A value of \"unlimited\", or zero, means there's no limit."),
2049 &setlist
, &showlist
);
2051 add_cmd ("substitute-path", class_files
, set_substitute_path_command
,
2053 Add a substitution rule to rewrite the source directories.\n\
2054 Usage: set substitute-path FROM TO\n\
2055 The rule is applied only if the directory name starts with FROM\n\
2056 directly followed by a directory separator.\n\
2057 If a substitution rule was previously set for FROM, the old rule\n\
2058 is replaced by the new one."),
2061 add_cmd ("substitute-path", class_files
, unset_substitute_path_command
,
2063 Delete one or all substitution rules rewriting the source directories.\n\
2064 Usage: unset substitute-path [FROM]\n\
2065 Delete the rule for substituting FROM in source directories. If FROM\n\
2066 is not specified, all substituting rules are deleted.\n\
2067 If the debugger cannot find a rule for FROM, it will display a warning."),
2070 add_cmd ("substitute-path", class_files
, show_substitute_path_command
,
2072 Show one or all substitution rules rewriting the source directories.\n\
2073 Usage: show substitute-path [FROM]\n\
2074 Print the rule for substituting FROM in source directories. If FROM\n\
2075 is not specified, print all substitution rules."),
2078 add_setshow_enum_cmd ("filename-display", class_files
,
2079 filename_display_kind_names
,
2080 &filename_display_string
, _("\
2081 Set how to display filenames."), _("\
2082 Show how to display filenames."), _("\
2083 filename-display can be:\n\
2084 basename - display only basename of a filename\n\
2085 relative - display a filename relative to the compilation directory\n\
2086 absolute - display an absolute filename\n\
2087 By default, relative filenames are displayed."),
2089 show_filename_display_string
,
2090 &setlist
, &showlist
);
2092 add_prefix_cmd ("source", no_class
, set_source
,
2093 _("Generic command for setting how sources are handled."),
2094 &setsourcelist
, 0, &setlist
);
2096 add_prefix_cmd ("source", no_class
, show_source
,
2097 _("Generic command for showing source settings."),
2098 &showsourcelist
, 0, &showlist
);
2100 add_setshow_boolean_cmd ("open", class_files
, &source_open
, _("\
2101 Set whether GDB should open source files."), _("\
2102 Show whether GDB should open source files."), _("\
2103 When this option is on GDB will open source files and display the\n\
2104 contents when appropriate, for example, when GDB stops, or the list\n\
2106 When this option is off GDB will not try to open source files, instead\n\
2107 GDB will print the file and line number that would have been displayed.\n\
2108 This can be useful if access to source code files is slow, for example\n\
2109 due to the source being located over a slow network connection."),
2112 &setsourcelist
, &showsourcelist
);