1 /* List lines of source files for GDB, the GNU debugger.
2 Copyright (C) 1986-2023 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "arch-utils.h"
22 #include "expression.h"
29 #include "gdbsupport/filestuff.h"
31 #include <sys/types.h>
34 #include "gdbsupport/gdb_regex.h"
40 #include "filenames.h"
41 #include "completer.h"
43 #include "readline/tilde.h"
44 #include "gdbsupport/enum-flags.h"
45 #include "gdbsupport/scoped_fd.h"
47 #include "gdbsupport/pathstuff.h"
48 #include "source-cache.h"
49 #include "cli/cli-style.h"
50 #include "observable.h"
52 #include "debuginfod-support.h"
53 #include "gdbsupport/buildargv.h"
56 #define OPEN_MODE (O_RDONLY | O_BINARY)
57 #define FDOPEN_MODE FOPEN_RB
59 /* Path of directories to search for source files.
60 Same format as the PATH environment variable's value. */
62 std::string source_path
;
64 /* Support for source path substitution commands. */
66 struct substitute_path_rule
68 substitute_path_rule (const char *from_
, const char *to_
)
78 static std::list
<substitute_path_rule
> substitute_path_rules
;
80 /* An instance of this is attached to each program space. */
82 struct current_source_location
86 current_source_location () = default;
89 void set (struct symtab
*s
, int l
)
93 gdb::observers::current_source_symtab_and_line_changed
.notify ();
97 struct symtab
*symtab () const
102 /* Get the line number. */
110 /* Symtab of default file for listing lines of. */
112 struct symtab
*m_symtab
= nullptr;
114 /* Default next line to list. */
119 static const registry
<program_space
>::key
<current_source_location
>
122 /* Default number of lines to print with commands like "list".
123 This is based on guessing how many long (i.e. more than chars_per_line
124 characters) lines there will be. To be completely correct, "list"
125 and friends should be rewritten to count characters and see where
126 things are wrapping, but that would be a fair amount of work. */
128 static int lines_to_list
= 10;
130 show_lines_to_list (struct ui_file
*file
, int from_tty
,
131 struct cmd_list_element
*c
, const char *value
)
134 _("Number of source lines gdb "
135 "will list by default is %s.\n"),
139 /* Possible values of 'set filename-display'. */
140 static const char filename_display_basename
[] = "basename";
141 static const char filename_display_relative
[] = "relative";
142 static const char filename_display_absolute
[] = "absolute";
144 static const char *const filename_display_kind_names
[] = {
145 filename_display_basename
,
146 filename_display_relative
,
147 filename_display_absolute
,
151 static const char *filename_display_string
= filename_display_relative
;
154 show_filename_display_string (struct ui_file
*file
, int from_tty
,
155 struct cmd_list_element
*c
, const char *value
)
157 gdb_printf (file
, _("Filenames are displayed as \"%s\".\n"), value
);
160 /* When true GDB will stat and open source files as required, but when
161 false, GDB will avoid accessing source files as much as possible. */
163 static bool source_open
= true;
165 /* Implement 'show source open'. */
168 show_source_open (struct ui_file
*file
, int from_tty
,
169 struct cmd_list_element
*c
, const char *value
)
171 gdb_printf (file
, _("Source opening is \"%s\".\n"), value
);
174 /* Line number of last line printed. Default for various commands.
175 current_source_line is usually, but not always, the same as this. */
177 static int last_line_listed
;
179 /* First line number listed by last listing command. If 0, then no
180 source lines have yet been listed since the last time the current
181 source line was changed. */
183 static int first_line_listed
;
185 /* Saves the name of the last source file visited and a possible error code.
186 Used to prevent repeating annoying "No such file or directories" msgs. */
188 static struct symtab
*last_source_visited
= NULL
;
189 static bool last_source_error
= false;
191 /* Return the first line listed by print_source_lines.
192 Used by command interpreters to request listing from
196 get_first_line_listed (void)
198 return first_line_listed
;
201 /* Clear line listed range. This makes the next "list" center the
202 printed source lines around the current source line. */
205 clear_lines_listed_range (void)
207 first_line_listed
= 0;
208 last_line_listed
= 0;
211 /* Return the default number of lines to print with commands like the
212 cli "list". The caller of print_source_lines must use this to
213 calculate the end line and use it in the call to print_source_lines
214 as it does not automatically use this value. */
217 get_lines_to_list (void)
219 return lines_to_list
;
222 /* A helper to return the current source location object for PSPACE,
223 creating it if it does not exist. */
225 static current_source_location
*
226 get_source_location (program_space
*pspace
)
228 current_source_location
*loc
229 = current_source_key
.get (pspace
);
231 loc
= current_source_key
.emplace (pspace
);
235 /* Return the current source file for listing and next line to list.
236 NOTE: The returned sal pc and end fields are not valid. */
238 struct symtab_and_line
239 get_current_source_symtab_and_line (void)
241 symtab_and_line cursal
;
242 current_source_location
*loc
= get_source_location (current_program_space
);
244 cursal
.pspace
= current_program_space
;
245 cursal
.symtab
= loc
->symtab ();
246 cursal
.line
= loc
->line ();
253 /* If the current source file for listing is not set, try and get a default.
254 Usually called before get_current_source_symtab_and_line() is called.
255 It may err out if a default cannot be determined.
256 We must be cautious about where it is called, as it can recurse as the
257 process of determining a new default may call the caller!
258 Use get_current_source_symtab_and_line only to get whatever
259 we have without erroring out or trying to get a default. */
262 set_default_source_symtab_and_line (void)
264 if (!have_full_symbols () && !have_partial_symbols ())
265 error (_("No symbol table is loaded. Use the \"file\" command."));
267 /* Pull in a current source symtab if necessary. */
268 current_source_location
*loc
= get_source_location (current_program_space
);
269 if (loc
->symtab () == nullptr)
270 select_source_symtab ();
273 /* Return the current default file for listing and next line to list
274 (the returned sal pc and end fields are not valid.)
275 and set the current default to whatever is in SAL.
276 NOTE: The returned sal pc and end fields are not valid. */
278 struct symtab_and_line
279 set_current_source_symtab_and_line (const symtab_and_line
&sal
)
281 symtab_and_line cursal
;
283 current_source_location
*loc
= get_source_location (sal
.pspace
);
285 cursal
.pspace
= sal
.pspace
;
286 cursal
.symtab
= loc
->symtab ();
287 cursal
.line
= loc
->line ();
291 loc
->set (sal
.symtab
, sal
.line
);
293 /* Force the next "list" to center around the current line. */
294 clear_lines_listed_range ();
299 /* Reset any information stored about a default file and line to print. */
302 clear_current_source_symtab_and_line (void)
304 current_source_location
*loc
= get_source_location (current_program_space
);
305 loc
->set (nullptr, 0);
311 select_source_symtab ()
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 && bsym
.symbol
->aclass () == 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 (bsym
.symbol
->symtab (), 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
: cu
->filetabs ())
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 symtab
*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 std::string 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
.empty ())
390 mod_path (set_path
.c_str (), source_path
);
393 /* Print the list of source directories.
394 This is used by the "ld" command, so it has the signature of a command
398 show_directories_1 (ui_file
*file
, char *ignore
, int from_tty
)
400 gdb_puts ("Source directories searched: ", file
);
401 gdb_puts (source_path
.c_str (), file
);
402 gdb_puts ("\n", file
);
405 /* Handler for "show directories" command. */
408 show_directories_command (struct ui_file
*file
, int from_tty
,
409 struct cmd_list_element
*c
, const char *value
)
411 show_directories_1 (file
, NULL
, from_tty
);
417 forget_cached_source_info (void)
419 for (struct program_space
*pspace
: program_spaces
)
420 for (objfile
*objfile
: pspace
->objfiles ())
421 objfile
->forget_cached_source_info ();
423 g_source_cache
.clear ();
424 last_source_visited
= NULL
;
428 init_source_path (void)
430 source_path
= string_printf ("$cdir%c$cwd", DIRNAME_SEPARATOR
);
431 forget_cached_source_info ();
434 /* Add zero or more directories to the front of the source path. */
437 directory_command (const char *dirname
, int from_tty
)
439 bool value_changed
= false;
441 /* FIXME, this goes to "delete dir"... */
444 if (!from_tty
|| query (_("Reinitialize source path to empty? ")))
447 value_changed
= true;
452 mod_path (dirname
, source_path
);
453 forget_cached_source_info ();
454 value_changed
= true;
458 interps_notify_param_changed ("directories", source_path
.c_str ());
461 show_directories_1 (gdb_stdout
, (char *) 0, from_tty
);
465 /* Add a path given with the -d command line switch.
466 This will not be quoted so we must not treat spaces as separators. */
469 directory_switch (const char *dirname
, int from_tty
)
471 add_path (dirname
, source_path
, 0);
474 /* Add zero or more directories to the front of an arbitrary path. */
477 mod_path (const char *dirname
, std::string
&which_path
)
479 add_path (dirname
, which_path
, 1);
482 /* Workhorse of mod_path. Takes an extra argument to determine
483 if dirname should be parsed for separators that indicate multiple
484 directories. This allows for interfaces that pre-parse the dirname
485 and allow specification of traditional separator characters such
489 add_path (const char *dirname
, char **which_path
, int parse_separators
)
491 char *old
= *which_path
;
493 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
;
498 if (parse_separators
)
500 /* This will properly parse the space and tab separators
501 and any quotes that may exist. */
502 gdb_argv
argv (dirname
);
504 for (char *arg
: argv
)
505 dirnames_to_char_ptr_vec_append (&dir_vec
, arg
);
508 dir_vec
.emplace_back (xstrdup (dirname
));
510 for (const gdb::unique_xmalloc_ptr
<char> &name_up
: dir_vec
)
512 const char *name
= name_up
.get ();
515 std::string new_name_holder
;
517 /* Spaces and tabs will have been removed by buildargv().
518 NAME is the start of the directory.
519 P is the '\0' following the end. */
520 p
= name_up
.get () + strlen (name
);
522 while (!(IS_DIR_SEPARATOR (*name
) && p
<= name
+ 1) /* "/" */
523 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
524 /* On MS-DOS and MS-Windows, h:\ is different from h: */
525 && !(p
== name
+ 3 && name
[1] == ':') /* "d:/" */
528 && IS_DIR_SEPARATOR (p
[-1]))
529 /* Sigh. "foo/" => "foo" */
533 while (p
> name
&& p
[-1] == '.')
537 /* "." => getwd (). */
538 name
= current_directory
;
541 else if (p
> name
+ 1 && IS_DIR_SEPARATOR (p
[-2]))
551 /* "...foo/." => "...foo". */
565 = gdb::unique_xmalloc_ptr
<char[]> (tilde_expand (name
)).get ();
566 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
567 else if (IS_ABSOLUTE_PATH (name
) && p
== name
+ 2) /* "d:" => "d:." */
568 new_name_holder
= std::string (name
) + ".";
570 else if (!IS_ABSOLUTE_PATH (name
) && name
[0] != '$')
571 new_name_holder
= gdb_abspath (name
);
573 new_name_holder
= std::string (name
, p
- name
);
575 name
= new_name_holder
.c_str ();
577 /* Unless it's a variable, check existence. */
580 /* These are warnings, not errors, since we don't want a
581 non-existent directory in a .gdbinit file to stop processing
582 of the .gdbinit file.
584 Whether they get added to the path is more debatable. Current
585 answer is yes, in case the user wants to go make the directory
586 or whatever. If the directory continues to not exist/not be
587 a directory/etc, then having them in the path should be
589 if (stat (name
, &st
) < 0)
590 warning_filename_and_errno (name
, errno
);
591 else if ((st
.st_mode
& S_IFMT
) != S_IFDIR
)
592 warning (_("%ps is not a directory."),
593 styled_string (file_name_style
.style (), name
));
598 unsigned int len
= strlen (name
);
604 /* FIXME: we should use realpath() or its work-alike
605 before comparing. Then all the code above which
606 removes excess slashes and dots could simply go away. */
607 if (!filename_ncmp (p
, name
, len
)
608 && (p
[len
] == '\0' || p
[len
] == DIRNAME_SEPARATOR
))
610 /* Found it in the search path, remove old copy. */
613 /* Back over leading separator. */
616 if (prefix
> p
- *which_path
)
618 /* Same dir twice in one cmd. */
621 /* Copy from next '\0' or ':'. */
622 memmove (p
, &p
[len
+ 1], strlen (&p
[len
+ 1]) + 1);
624 p
= strchr (p
, DIRNAME_SEPARATOR
);
631 tinybuf
[0] = DIRNAME_SEPARATOR
;
634 /* If we have already tacked on a name(s) in this command,
635 be sure they stay on the front as we tack on some
639 std::string temp
= std::string (old
, prefix
) + tinybuf
+ name
;
640 *which_path
= concat (temp
.c_str (), &old
[prefix
],
642 prefix
= temp
.length ();
646 *which_path
= concat (name
, (old
[0] ? tinybuf
: old
),
648 prefix
= strlen (name
);
658 /* add_path would need to be re-written to work on an std::string, but this is
659 not trivial. Hence this overload which copies to a `char *` and back. */
662 add_path (const char *dirname
, std::string
&which_path
, int parse_separators
)
664 char *which_path_copy
= xstrdup (which_path
.data ());
665 add_path (dirname
, &which_path_copy
, parse_separators
);
666 which_path
= which_path_copy
;
667 xfree (which_path_copy
);
671 info_source_command (const char *ignore
, int from_tty
)
673 current_source_location
*loc
674 = get_source_location (current_program_space
);
675 struct symtab
*s
= loc
->symtab ();
676 struct compunit_symtab
*cust
;
680 gdb_printf (_("No current source file.\n"));
684 cust
= s
->compunit ();
685 gdb_printf (_("Current source file is %s\n"), s
->filename
);
686 if (s
->compunit ()->dirname () != NULL
)
687 gdb_printf (_("Compilation directory is %s\n"), s
->compunit ()->dirname ());
689 gdb_printf (_("Located in %s\n"), s
->fullname
);
690 const std::vector
<off_t
> *offsets
;
691 if (g_source_cache
.get_line_charpos (s
, &offsets
))
692 gdb_printf (_("Contains %d line%s.\n"), (int) offsets
->size (),
693 offsets
->size () == 1 ? "" : "s");
695 gdb_printf (_("Source language is %s.\n"),
696 language_str (s
->language ()));
697 gdb_printf (_("Producer is %s.\n"),
698 (cust
->producer ()) != nullptr
699 ? cust
->producer () : _("unknown"));
700 gdb_printf (_("Compiled with %s debugging format.\n"),
701 cust
->debugformat ());
702 gdb_printf (_("%s preprocessor macro info.\n"),
703 (cust
->macro_table () != nullptr
704 ? "Includes" : "Does not include"));
708 /* Helper function to remove characters from the start of PATH so that
709 PATH can then be appended to a directory name. We remove leading drive
710 letters (for dos) as well as leading '/' characters and './'
714 prepare_path_for_appending (const char *path
)
716 /* For dos paths, d:/foo -> /foo, and d:foo -> foo. */
717 if (HAS_DRIVE_SPEC (path
))
718 path
= STRIP_DRIVE_SPEC (path
);
720 const char *old_path
;
725 /* /foo => foo, to avoid multiple slashes that Emacs doesn't like. */
726 while (IS_DIR_SEPARATOR(path
[0]))
730 while (path
[0] == '.' && IS_DIR_SEPARATOR (path
[1]))
733 while (old_path
!= path
);
738 /* Open a file named STRING, searching path PATH (dir names sep by some char)
739 using mode MODE in the calls to open. You cannot use this function to
740 create files (O_CREAT).
742 OPTS specifies the function behaviour in specific cases.
744 If OPF_TRY_CWD_FIRST, try to open ./STRING before searching PATH.
745 (ie pretend the first element of PATH is "."). This also indicates
746 that, unless OPF_SEARCH_IN_PATH is also specified, a slash in STRING
747 disables searching of the path (this is so that "exec-file ./foo" or
748 "symbol-file ./foo" insures that you get that particular version of
749 foo or an error message).
751 If OPTS has OPF_SEARCH_IN_PATH set, absolute names will also be
752 searched in path (we usually want this for source files but not for
755 If FILENAME_OPENED is non-null, set it to a newly allocated string naming
756 the actual file opened (this string will always start with a "/"). We
757 have to take special pains to avoid doubling the "/" between the directory
758 and the file, sigh! Emacs gets confuzzed by this when we print the
761 If OPTS has OPF_RETURN_REALPATH set return FILENAME_OPENED resolved by
762 gdb_realpath. Even without OPF_RETURN_REALPATH this function still returns
763 filename starting with "/". If FILENAME_OPENED is NULL this option has no
766 If a file is found, return the descriptor.
767 Otherwise, return -1, with errno set for the last name we tried to open. */
769 /* >>>> This should only allow files of certain types,
770 >>>> eg executable, non-directory. */
772 openp (const char *path
, openp_flags opts
, const char *string
,
773 int mode
, gdb::unique_xmalloc_ptr
<char> *filename_opened
)
778 /* The errno set for the last name we tried to open (and
781 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
;
783 /* The open syscall MODE parameter is not specified. */
784 gdb_assert ((mode
& O_CREAT
) == 0);
785 gdb_assert (string
!= NULL
);
787 /* A file with an empty name cannot possibly exist. Report a failure
788 without further checking.
790 This is an optimization which also defends us against buggy
791 implementations of the "stat" function. For instance, we have
792 noticed that a MinGW debugger built on Windows XP 32bits crashes
793 when the debugger is started with an empty argument. */
794 if (string
[0] == '\0')
805 if ((opts
& OPF_TRY_CWD_FIRST
) || IS_ABSOLUTE_PATH (string
))
807 int i
, reg_file_errno
;
809 if (is_regular_file (string
, ®_file_errno
))
811 filename
= (char *) alloca (strlen (string
) + 1);
812 strcpy (filename
, string
);
813 fd
= gdb_open_cloexec (filename
, mode
, 0).release ();
822 last_errno
= reg_file_errno
;
825 if (!(opts
& OPF_SEARCH_IN_PATH
))
826 for (i
= 0; string
[i
]; i
++)
827 if (IS_DIR_SEPARATOR (string
[i
]))
831 /* Remove characters from the start of PATH that we don't need when PATH
832 is appended to a directory name. */
833 string
= prepare_path_for_appending (string
);
835 alloclen
= strlen (path
) + strlen (string
) + 2;
836 filename
= (char *) alloca (alloclen
);
840 dir_vec
= dirnames_to_char_ptr_vec (path
);
842 for (const gdb::unique_xmalloc_ptr
<char> &dir_up
: dir_vec
)
844 char *dir
= dir_up
.get ();
845 size_t len
= strlen (dir
);
848 if (strcmp (dir
, "$cwd") == 0)
850 /* Name is $cwd -- insert current directory name instead. */
853 /* First, realloc the filename buffer if too short. */
854 len
= strlen (current_directory
);
855 newlen
= len
+ strlen (string
) + 2;
856 if (newlen
> alloclen
)
859 filename
= (char *) alloca (alloclen
);
861 strcpy (filename
, current_directory
);
863 else if (strchr(dir
, '~'))
865 /* See whether we need to expand the tilde. */
868 gdb::unique_xmalloc_ptr
<char> tilde_expanded (tilde_expand (dir
));
870 /* First, realloc the filename buffer if too short. */
871 len
= strlen (tilde_expanded
.get ());
872 newlen
= len
+ strlen (string
) + 2;
873 if (newlen
> alloclen
)
876 filename
= (char *) alloca (alloclen
);
878 strcpy (filename
, tilde_expanded
.get ());
882 /* Normal file name in path -- just use it. */
883 strcpy (filename
, dir
);
885 /* Don't search $cdir. It's also a magic path like $cwd, but we
886 don't have enough information to expand it. The user *could*
887 have an actual directory named '$cdir' but handling that would
888 be confusing, it would mean different things in different
889 contexts. If the user really has '$cdir' one can use './$cdir'.
890 We can get $cdir when loading scripts. When loading source files
891 $cdir must have already been expanded to the correct value. */
892 if (strcmp (dir
, "$cdir") == 0)
896 /* Remove trailing slashes. */
897 while (len
> 0 && IS_DIR_SEPARATOR (filename
[len
- 1]))
900 strcat (filename
+ len
, SLASH_STRING
);
901 strcat (filename
, string
);
903 if (is_regular_file (filename
, ®_file_errno
))
905 fd
= gdb_open_cloexec (filename
, mode
, 0).release ();
911 last_errno
= reg_file_errno
;
917 /* If a file was opened, canonicalize its filename. */
919 filename_opened
->reset (NULL
);
920 else if ((opts
& OPF_RETURN_REALPATH
) != 0)
921 *filename_opened
= gdb_realpath (filename
);
924 = make_unique_xstrdup (gdb_abspath (filename
).c_str ());
932 /* This is essentially a convenience, for clients that want the behaviour
933 of openp, using source_path, but that really don't want the file to be
934 opened but want instead just to know what the full pathname is (as
935 qualified against source_path).
937 The current working directory is searched first.
939 If the file was found, this function returns 1, and FULL_PATHNAME is
940 set to the fully-qualified pathname.
942 Else, this functions returns 0, and FULL_PATHNAME is set to NULL. */
944 source_full_path_of (const char *filename
,
945 gdb::unique_xmalloc_ptr
<char> *full_pathname
)
949 fd
= openp (source_path
.c_str (),
950 OPF_TRY_CWD_FIRST
| OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
,
951 filename
, O_RDONLY
, full_pathname
);
954 full_pathname
->reset (NULL
);
962 /* Return non-zero if RULE matches PATH, that is if the rule can be
966 substitute_path_rule_matches (const struct substitute_path_rule
*rule
,
969 const int from_len
= rule
->from
.length ();
970 const int path_len
= strlen (path
);
972 if (path_len
< from_len
)
975 /* The substitution rules are anchored at the start of the path,
976 so the path should start with rule->from. */
978 if (filename_ncmp (path
, rule
->from
.c_str (), from_len
) != 0)
981 /* Make sure that the region in the path that matches the substitution
982 rule is immediately followed by a directory separator (or the end of
983 string character). */
985 if (path
[from_len
] != '\0' && !IS_DIR_SEPARATOR (path
[from_len
]))
991 /* Find the substitute-path rule that applies to PATH and return it.
992 Return NULL if no rule applies. */
994 static struct substitute_path_rule
*
995 get_substitute_path_rule (const char *path
)
997 for (substitute_path_rule
&rule
: substitute_path_rules
)
998 if (substitute_path_rule_matches (&rule
, path
))
1004 /* If the user specified a source path substitution rule that applies
1005 to PATH, then apply it and return the new path.
1007 Return NULL if no substitution rule was specified by the user,
1008 or if no rule applied to the given PATH. */
1010 gdb::unique_xmalloc_ptr
<char>
1011 rewrite_source_path (const char *path
)
1013 const struct substitute_path_rule
*rule
= get_substitute_path_rule (path
);
1015 if (rule
== nullptr)
1018 /* Compute the rewritten path and return it. */
1020 return (gdb::unique_xmalloc_ptr
<char>
1021 (concat (rule
->to
.c_str (), path
+ rule
->from
.length (), nullptr)));
1027 find_and_open_source (const char *filename
,
1028 const char *dirname
,
1029 gdb::unique_xmalloc_ptr
<char> *fullname
)
1031 const char *path
= source_path
.c_str ();
1032 std::string expanded_path_holder
;
1035 /* If reading of source files is disabled then return a result indicating
1036 the attempt to read this source file failed. GDB will then display
1037 the filename and line number instead. */
1039 return scoped_fd (-ECANCELED
);
1041 /* Quick way out if we already know its full name. */
1044 /* The user may have requested that source paths be rewritten
1045 according to substitution rules he provided. If a substitution
1046 rule applies to this path, then apply it. */
1047 gdb::unique_xmalloc_ptr
<char> rewritten_fullname
1048 = rewrite_source_path (fullname
->get ());
1050 if (rewritten_fullname
!= NULL
)
1051 *fullname
= std::move (rewritten_fullname
);
1053 scoped_fd result
= gdb_open_cloexec (fullname
->get (), OPEN_MODE
, 0);
1054 if (result
.get () >= 0)
1056 *fullname
= gdb_realpath (fullname
->get ());
1060 /* Didn't work -- free old one, try again. */
1061 fullname
->reset (NULL
);
1064 gdb::unique_xmalloc_ptr
<char> rewritten_dirname
;
1065 if (dirname
!= NULL
)
1067 /* If necessary, rewrite the compilation directory name according
1068 to the source path substitution rules specified by the user. */
1070 rewritten_dirname
= rewrite_source_path (dirname
);
1072 if (rewritten_dirname
!= NULL
)
1073 dirname
= rewritten_dirname
.get ();
1075 /* Replace a path entry of $cdir with the compilation directory
1078 p
= strstr (source_path
.c_str (), "$cdir");
1079 if (p
&& (p
== path
|| p
[-1] == DIRNAME_SEPARATOR
)
1080 && (p
[cdir_len
] == DIRNAME_SEPARATOR
|| p
[cdir_len
] == '\0'))
1082 int len
= p
- source_path
.c_str ();
1085 expanded_path_holder
= source_path
.substr (0, len
);
1088 expanded_path_holder
+= dirname
;
1091 expanded_path_holder
+= source_path
.c_str () + len
+ cdir_len
;
1093 path
= expanded_path_holder
.c_str ();
1097 gdb::unique_xmalloc_ptr
<char> rewritten_filename
1098 = rewrite_source_path (filename
);
1100 if (rewritten_filename
!= NULL
)
1101 filename
= rewritten_filename
.get ();
1103 /* Try to locate file using filename. */
1104 int result
= openp (path
, OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
, filename
,
1105 OPEN_MODE
, fullname
);
1106 if (result
< 0 && dirname
!= NULL
)
1108 /* Remove characters from the start of PATH that we don't need when
1109 PATH is appended to a directory name. */
1110 const char *filename_start
= prepare_path_for_appending (filename
);
1112 /* Try to locate file using compilation dir + filename. This is
1113 helpful if part of the compilation directory was removed,
1114 e.g. using gcc's -fdebug-prefix-map, and we have added the missing
1115 prefix to source_path. */
1116 std::string cdir_filename
= path_join (dirname
, filename_start
);
1118 result
= openp (path
, OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
,
1119 cdir_filename
.c_str (), OPEN_MODE
, fullname
);
1123 /* Didn't work. Try using just the basename. */
1124 p
= lbasename (filename
);
1126 result
= openp (path
, OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
, p
,
1127 OPEN_MODE
, fullname
);
1130 /* If the file wasn't found, then openp will have set errno accordingly. */
1134 return scoped_fd (result
);
1137 /* Open a source file given a symtab S. Returns a file descriptor or
1138 negative errno for error.
1140 This function is a convenience function to find_and_open_source. */
1143 open_source_file (struct symtab
*s
)
1146 return scoped_fd (-EINVAL
);
1148 gdb::unique_xmalloc_ptr
<char> fullname (s
->fullname
);
1150 scoped_fd fd
= find_and_open_source (s
->filename
, s
->compunit ()->dirname (),
1155 if (s
->compunit () != nullptr)
1157 const objfile
*ofp
= s
->compunit ()->objfile ();
1159 std::string srcpath
;
1160 if (IS_ABSOLUTE_PATH (s
->filename
))
1161 srcpath
= s
->filename
;
1162 else if (s
->compunit ()->dirname () != nullptr)
1164 srcpath
= s
->compunit ()->dirname ();
1165 srcpath
+= SLASH_STRING
;
1166 srcpath
+= s
->filename
;
1169 const struct bfd_build_id
*build_id
1170 = build_id_bfd_get (ofp
->obfd
.get ());
1172 /* Query debuginfod for the source file. */
1173 if (build_id
!= nullptr && !srcpath
.empty ())
1176 = debuginfod_source_query (build_id
->data
,
1181 /* Don't return a negative errno from debuginfod_source_query.
1182 It handles the reporting of its own errors. */
1183 if (query_fd
.get () >= 0)
1185 s
->fullname
= fullname
.release ();
1192 s
->fullname
= fullname
.release ();
1198 gdb::unique_xmalloc_ptr
<char>
1199 find_source_or_rewrite (const char *filename
, const char *dirname
)
1201 gdb::unique_xmalloc_ptr
<char> fullname
;
1203 scoped_fd fd
= find_and_open_source (filename
, dirname
, &fullname
);
1206 /* rewrite_source_path would be applied by find_and_open_source, we
1207 should report the pathname where GDB tried to find the file. */
1209 if (dirname
== nullptr || IS_ABSOLUTE_PATH (filename
))
1210 fullname
.reset (xstrdup (filename
));
1212 fullname
.reset (concat (dirname
, SLASH_STRING
,
1213 filename
, (char *) nullptr));
1215 gdb::unique_xmalloc_ptr
<char> rewritten
1216 = rewrite_source_path (fullname
.get ());
1217 if (rewritten
!= nullptr)
1218 fullname
= std::move (rewritten
);
1224 /* Finds the fullname that a symtab represents.
1226 This functions finds the fullname and saves it in s->fullname.
1227 It will also return the value.
1229 If this function fails to find the file that this symtab represents,
1230 the expected fullname is used. Therefore the files does not have to
1234 symtab_to_fullname (struct symtab
*s
)
1236 /* Use cached copy if we have it.
1237 We rely on forget_cached_source_info being called appropriately
1238 to handle cases like the file being moved. */
1239 if (s
->fullname
== NULL
)
1241 scoped_fd fd
= open_source_file (s
);
1245 gdb::unique_xmalloc_ptr
<char> fullname
;
1247 /* rewrite_source_path would be applied by find_and_open_source, we
1248 should report the pathname where GDB tried to find the file. */
1250 if (s
->compunit ()->dirname () == nullptr
1251 || IS_ABSOLUTE_PATH (s
->filename
))
1252 fullname
.reset (xstrdup (s
->filename
));
1254 fullname
.reset (concat (s
->compunit ()->dirname (), SLASH_STRING
,
1255 s
->filename
, (char *) NULL
));
1257 s
->fullname
= rewrite_source_path (fullname
.get ()).release ();
1258 if (s
->fullname
== NULL
)
1259 s
->fullname
= fullname
.release ();
1266 /* See commentary in source.h. */
1269 symtab_to_filename_for_display (struct symtab
*symtab
)
1271 if (filename_display_string
== filename_display_basename
)
1272 return lbasename (symtab
->filename
);
1273 else if (filename_display_string
== filename_display_absolute
)
1274 return symtab_to_fullname (symtab
);
1275 else if (filename_display_string
== filename_display_relative
)
1276 return symtab
->filename
;
1278 internal_error (_("invalid filename_display_string"));
1283 /* Print source lines from the file of symtab S,
1284 starting with line number LINE and stopping before line number STOPLINE. */
1287 print_source_lines_base (struct symtab
*s
, int line
, int stopline
,
1288 print_source_lines_flags flags
)
1290 bool noprint
= false;
1291 int errcode
= ENOENT
;
1292 int nlines
= stopline
- line
;
1293 struct ui_out
*uiout
= current_uiout
;
1295 /* Regardless of whether we can open the file, set current_source_symtab. */
1296 current_source_location
*loc
1297 = get_source_location (current_program_space
);
1300 first_line_listed
= line
;
1301 last_line_listed
= line
;
1303 /* If printing of source lines is disabled, just print file and line
1305 if (uiout
->test_flags (ui_source_list
) && source_open
)
1307 /* Only prints "No such file or directory" once. */
1308 if (s
== last_source_visited
)
1310 if (last_source_error
)
1312 flags
|= PRINT_SOURCE_LINES_NOERROR
;
1318 last_source_visited
= s
;
1319 scoped_fd desc
= open_source_file (s
);
1320 last_source_error
= desc
.get () < 0;
1321 if (last_source_error
)
1324 errcode
= -desc
.get ();
1330 flags
|= PRINT_SOURCE_LINES_NOERROR
;
1336 if (!(flags
& PRINT_SOURCE_LINES_NOERROR
))
1338 const char *filename
= symtab_to_filename_for_display (s
);
1339 warning (_("%d\t%ps: %s"), line
,
1340 styled_string (file_name_style
.style (), filename
),
1341 safe_strerror (errcode
));
1345 uiout
->field_signed ("line", line
);
1346 uiout
->text ("\tin ");
1348 /* CLI expects only the "file" field. TUI expects only the
1349 "fullname" field (and TUI does break if "file" is printed).
1350 MI expects both fields. ui_source_list is set only for CLI,
1352 if (uiout
->is_mi_like_p () || uiout
->test_flags (ui_source_list
))
1353 uiout
->field_string ("file", symtab_to_filename_for_display (s
),
1354 file_name_style
.style ());
1355 if (uiout
->is_mi_like_p () || !uiout
->test_flags (ui_source_list
))
1357 const char *s_fullname
= symtab_to_fullname (s
);
1358 char *local_fullname
;
1360 /* ui_out_field_string may free S_FULLNAME by calling
1361 open_source_file for it again. See e.g.,
1362 tui_field_string->tui_show_source. */
1363 local_fullname
= (char *) alloca (strlen (s_fullname
) + 1);
1364 strcpy (local_fullname
, s_fullname
);
1366 uiout
->field_string ("fullname", local_fullname
);
1375 /* If the user requested a sequence of lines that seems to go backward
1376 (from high to low line numbers) then we don't print anything. */
1377 if (stopline
<= line
)
1381 if (!g_source_cache
.get_source_lines (s
, line
, stopline
- 1, &lines
))
1383 const std::vector
<off_t
> *offsets
= nullptr;
1384 g_source_cache
.get_line_charpos (s
, &offsets
);
1385 error (_("Line number %d out of range; %s has %d lines."),
1386 line
, symtab_to_filename_for_display (s
),
1387 offsets
== nullptr ? 0 : (int) offsets
->size ());
1390 const char *iter
= lines
.c_str ();
1391 int new_lineno
= loc
->line ();
1392 while (nlines
-- > 0 && *iter
!= '\0')
1396 last_line_listed
= loc
->line ();
1397 if (flags
& PRINT_SOURCE_LINES_FILENAME
)
1399 uiout
->text (symtab_to_filename_for_display (s
));
1402 xsnprintf (buf
, sizeof (buf
), "%d\t", new_lineno
++);
1405 while (*iter
!= '\0')
1407 /* Find a run of characters that can be emitted at once.
1408 This is done so that escape sequences are kept
1410 const char *start
= iter
;
1416 if (c
== '\033' && skip_ansi_escape (iter
, &skip_bytes
))
1418 else if (c
>= 0 && c
< 040 && c
!= '\t')
1427 std::string
text (start
, iter
);
1432 /* Treat either \r or \r\n as a single newline. */
1438 else if (*iter
== '\n')
1443 else if (*iter
> 0 && *iter
< 040)
1445 xsnprintf (buf
, sizeof (buf
), "^%c", *iter
+ 0100);
1449 else if (*iter
== 0177)
1458 loc
->set (loc
->symtab (), new_lineno
);
1465 print_source_lines (struct symtab
*s
, int line
, int stopline
,
1466 print_source_lines_flags flags
)
1468 print_source_lines_base (s
, line
, stopline
, flags
);
1474 print_source_lines (struct symtab
*s
, source_lines_range line_range
,
1475 print_source_lines_flags flags
)
1477 print_source_lines_base (s
, line_range
.startline (),
1478 line_range
.stopline (), flags
);
1484 last_symtab_line (struct symtab
*s
)
1486 const std::vector
<off_t
> *offsets
;
1488 /* Try to get the offsets for the start of each line. */
1489 if (!g_source_cache
.get_line_charpos (s
, &offsets
))
1491 if (offsets
== nullptr)
1494 return offsets
->size ();
1499 /* Print info on range of pc's in a specified line. */
1502 info_line_command (const char *arg
, int from_tty
)
1504 CORE_ADDR start_pc
, end_pc
;
1506 std::vector
<symtab_and_line
> decoded_sals
;
1507 symtab_and_line curr_sal
;
1508 gdb::array_view
<symtab_and_line
> sals
;
1512 current_source_location
*loc
1513 = get_source_location (current_program_space
);
1514 curr_sal
.symtab
= loc
->symtab ();
1515 curr_sal
.pspace
= current_program_space
;
1516 if (last_line_listed
!= 0)
1517 curr_sal
.line
= last_line_listed
;
1519 curr_sal
.line
= loc
->line ();
1525 decoded_sals
= decode_line_with_last_displayed (arg
,
1526 DECODE_LINE_LIST_MODE
);
1527 sals
= decoded_sals
;
1532 /* C++ More than one line may have been specified, as when the user
1533 specifies an overloaded function name. Print info on them all. */
1534 for (const auto &sal
: sals
)
1536 if (sal
.pspace
!= current_program_space
)
1539 if (sal
.symtab
== 0)
1541 struct gdbarch
*gdbarch
= get_current_arch ();
1543 gdb_printf (_("No line number information available"));
1546 /* This is useful for "info line *0x7f34". If we can't tell the
1547 user about a source line, at least let them have the symbolic
1549 gdb_printf (" for address ");
1550 gdb_stdout
->wrap_here (2);
1551 print_address (gdbarch
, sal
.pc
, gdb_stdout
);
1557 else if (sal
.line
> 0
1558 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
1560 gdbarch
*gdbarch
= sal
.symtab
->compunit ()->objfile ()->arch ();
1562 if (start_pc
== end_pc
)
1564 gdb_printf ("Line %d of \"%s\"",
1566 symtab_to_filename_for_display (sal
.symtab
));
1567 gdb_stdout
->wrap_here (2);
1568 gdb_printf (" is at address ");
1569 print_address (gdbarch
, start_pc
, gdb_stdout
);
1570 gdb_stdout
->wrap_here (2);
1571 gdb_printf (" but contains no code.\n");
1575 gdb_printf ("Line %d of \"%s\"",
1577 symtab_to_filename_for_display (sal
.symtab
));
1578 gdb_stdout
->wrap_here (2);
1579 gdb_printf (" starts at address ");
1580 print_address (gdbarch
, start_pc
, gdb_stdout
);
1581 gdb_stdout
->wrap_here (2);
1582 gdb_printf (" and ends at ");
1583 print_address (gdbarch
, end_pc
, gdb_stdout
);
1587 /* x/i should display this line's code. */
1588 set_next_address (gdbarch
, start_pc
);
1590 /* Repeating "info line" should do the following line. */
1591 last_line_listed
= sal
.line
+ 1;
1593 /* If this is the only line, show the source code. If it could
1594 not find the file, don't do anything special. */
1595 if (annotation_level
> 0 && sals
.size () == 1)
1596 annotate_source_line (sal
.symtab
, sal
.line
, 0, start_pc
);
1599 /* Is there any case in which we get here, and have an address
1600 which the user would want to see? If we have debugging symbols
1601 and no line numbers? */
1602 gdb_printf (_("Line number %d is out of range for \"%s\".\n"),
1603 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
1607 /* Commands to search the source file for a regexp. */
1609 /* Helper for forward_search_command/reverse_search_command. FORWARD
1610 indicates direction: true for forward, false for
1611 backward/reverse. */
1614 search_command_helper (const char *regex
, int from_tty
, bool forward
)
1616 const char *msg
= re_comp (regex
);
1618 error (("%s"), msg
);
1620 current_source_location
*loc
1621 = get_source_location (current_program_space
);
1622 if (loc
->symtab () == nullptr)
1623 select_source_symtab ();
1626 error (_("source code access disabled"));
1628 scoped_fd
desc (open_source_file (loc
->symtab ()));
1629 if (desc
.get () < 0)
1630 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 gdb_printf (_("Expression not found\n"));
1705 forward_search_command (const char *regex
, int from_tty
)
1707 search_command_helper (regex
, from_tty
, true);
1711 reverse_search_command (const char *regex
, int from_tty
)
1713 search_command_helper (regex
, from_tty
, false);
1716 /* If the last character of PATH is a directory separator, then strip it. */
1719 strip_trailing_directory_separator (char *path
)
1721 const int last
= strlen (path
) - 1;
1724 return; /* No stripping is needed if PATH is the empty string. */
1726 if (IS_DIR_SEPARATOR (path
[last
]))
1730 /* Add a new substitute-path rule at the end of the current list of rules.
1731 The new rule will replace FROM into TO. */
1734 add_substitute_path_rule (const char *from
, const char *to
)
1736 substitute_path_rules
.emplace_back (from
, to
);
1739 /* Implement the "show substitute-path" command. */
1742 show_substitute_path_command (const char *args
, int from_tty
)
1746 gdb_argv
argv (args
);
1748 /* We expect zero or one argument. */
1750 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1751 error (_("Too many arguments in command"));
1753 if (argv
!= NULL
&& argv
[0] != NULL
)
1756 /* Print the substitution rules. */
1760 (_("Source path substitution rule matching `%s':\n"), from
);
1762 gdb_printf (_("List of all source path substitution rules:\n"));
1764 for (substitute_path_rule
&rule
: substitute_path_rules
)
1766 if (from
== NULL
|| substitute_path_rule_matches (&rule
, from
) != 0)
1767 gdb_printf (" `%s' -> `%s'.\n", rule
.from
.c_str (),
1772 /* Implement the "unset substitute-path" command. */
1775 unset_substitute_path_command (const char *args
, int from_tty
)
1777 gdb_argv
argv (args
);
1780 /* This function takes either 0 or 1 argument. */
1782 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1783 error (_("Incorrect usage, too many arguments in command"));
1785 if (argv
!= NULL
&& argv
[0] != NULL
)
1788 /* If the user asked for all the rules to be deleted, ask him
1789 to confirm and give him a chance to abort before the action
1793 && !query (_("Delete all source path substitution rules? ")))
1794 error (_("Canceled"));
1796 /* Delete the rule matching the argument. No argument means that
1797 all rules should be deleted. */
1799 if (from
== nullptr)
1800 substitute_path_rules
.clear ();
1804 = std::remove_if (substitute_path_rules
.begin (),
1805 substitute_path_rules
.end (),
1806 [&] (const substitute_path_rule
&rule
)
1808 return FILENAME_CMP (from
,
1809 rule
.from
.c_str ()) == 0;
1811 bool rule_found
= iter
!= substitute_path_rules
.end ();
1812 substitute_path_rules
.erase (iter
, substitute_path_rules
.end ());
1814 /* If the user asked for a specific rule to be deleted but
1815 we could not find it, then report an error. */
1818 error (_("No substitution rule defined for `%s'"), from
);
1821 forget_cached_source_info ();
1824 /* Add a new source path substitution rule. */
1827 set_substitute_path_command (const char *args
, int from_tty
)
1829 gdb_argv
argv (args
);
1831 if (argv
== NULL
|| argv
[0] == NULL
|| argv
[1] == NULL
)
1832 error (_("Incorrect usage, too few arguments in command"));
1834 if (argv
[2] != NULL
)
1835 error (_("Incorrect usage, too many arguments in command"));
1837 if (*(argv
[0]) == '\0')
1838 error (_("First argument must be at least one character long"));
1840 /* Strip any trailing directory separator character in either FROM
1841 or TO. The substitution rule already implicitly contains them. */
1842 strip_trailing_directory_separator (argv
[0]);
1843 strip_trailing_directory_separator (argv
[1]);
1845 /* If a rule with the same "from" was previously defined, then
1846 delete it. This new rule replaces it. */
1849 = std::remove_if (substitute_path_rules
.begin (),
1850 substitute_path_rules
.end (),
1851 [&] (const substitute_path_rule
&rule
)
1853 return FILENAME_CMP (argv
[0], rule
.from
.c_str ()) == 0;
1855 substitute_path_rules
.erase (iter
, substitute_path_rules
.end ());
1857 /* Insert the new substitution rule. */
1859 add_substitute_path_rule (argv
[0], argv
[1]);
1860 forget_cached_source_info ();
1865 source_lines_range::source_lines_range (int startline
,
1866 source_lines_range::direction dir
)
1868 if (dir
== source_lines_range::FORWARD
)
1870 LONGEST end
= static_cast <LONGEST
> (startline
) + get_lines_to_list ();
1875 m_startline
= startline
;
1876 m_stopline
= static_cast <int> (end
);
1880 LONGEST start
= static_cast <LONGEST
> (startline
) - get_lines_to_list ();
1885 m_startline
= static_cast <int> (start
);
1886 m_stopline
= startline
;
1890 /* Handle the "set source" base command. */
1893 set_source (const char *arg
, int from_tty
)
1895 help_list (setsourcelist
, "set source ", all_commands
, gdb_stdout
);
1898 /* Handle the "show source" base command. */
1901 show_source (const char *args
, int from_tty
)
1903 help_list (showsourcelist
, "show source ", all_commands
, gdb_stdout
);
1907 void _initialize_source ();
1909 _initialize_source ()
1911 init_source_path ();
1913 /* The intention is to use POSIX Basic Regular Expressions.
1914 Always use the GNU regex routine for consistency across all hosts.
1915 Our current GNU regex.c does not have all the POSIX features, so this is
1916 just an approximation. */
1917 re_set_syntax (RE_SYNTAX_GREP
);
1919 cmd_list_element
*directory_cmd
1920 = add_cmd ("directory", class_files
, directory_command
, _("\
1921 Add directory DIR to beginning of search path for source files.\n\
1922 Forget cached info on source file locations and line positions.\n\
1923 DIR can also be $cwd for the current working directory, or $cdir for the\n\
1924 directory in which the source file was compiled into object code.\n\
1925 With no argument, reset the search path to $cdir:$cwd, the default."),
1928 set_cmd_completer (directory_cmd
, filename_completer
);
1930 add_setshow_optional_filename_cmd ("directories",
1934 Set the search path for finding source files."),
1936 Show the search path for finding source files."),
1938 $cwd in the path means the current working directory.\n\
1939 $cdir in the path means the compilation directory of the source file.\n\
1940 GDB ensures the search path always ends with $cdir:$cwd by\n\
1941 appending these directories if necessary.\n\
1942 Setting the value to an empty string sets it to $cdir:$cwd, the default."),
1943 set_directories_command
,
1944 show_directories_command
,
1945 &setlist
, &showlist
);
1947 add_info ("source", info_source_command
,
1948 _("Information about the current source file."));
1950 add_info ("line", info_line_command
, _("\
1951 Core addresses of the code for a source line.\n\
1952 Line can be specified as\n\
1953 LINENUM, to list around that line in current file,\n\
1954 FILE:LINENUM, to list around that line in that file,\n\
1955 FUNCTION, to list around beginning of that function,\n\
1956 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1957 Default is to describe the last source line that was listed.\n\n\
1958 This sets the default address for \"x\" to the line's first instruction\n\
1959 so that \"x/i\" suffices to start examining the machine code.\n\
1960 The address is also stored as the value of \"$_\"."));
1962 cmd_list_element
*forward_search_cmd
1963 = add_com ("forward-search", class_files
, forward_search_command
, _("\
1964 Search for regular expression (see regex(3)) from last line listed.\n\
1965 The matching line number is also stored as the value of \"$_\"."));
1966 add_com_alias ("search", forward_search_cmd
, class_files
, 0);
1967 add_com_alias ("fo", forward_search_cmd
, class_files
, 1);
1969 cmd_list_element
*reverse_search_cmd
1970 = add_com ("reverse-search", class_files
, reverse_search_command
, _("\
1971 Search backward for regular expression (see regex(3)) from last line listed.\n\
1972 The matching line number is also stored as the value of \"$_\"."));
1973 add_com_alias ("rev", reverse_search_cmd
, class_files
, 1);
1975 add_setshow_integer_cmd ("listsize", class_support
, &lines_to_list
, _("\
1976 Set number of source lines gdb will list by default."), _("\
1977 Show number of source lines gdb will list by default."), _("\
1978 Use this to choose how many source lines the \"list\" displays (unless\n\
1979 the \"list\" argument explicitly specifies some other number).\n\
1980 A value of \"unlimited\", or zero, means there's no limit."),
1983 &setlist
, &showlist
);
1985 add_cmd ("substitute-path", class_files
, set_substitute_path_command
,
1987 Add a substitution rule to rewrite the source directories.\n\
1988 Usage: set substitute-path FROM TO\n\
1989 The rule is applied only if the directory name starts with FROM\n\
1990 directly followed by a directory separator.\n\
1991 If a substitution rule was previously set for FROM, the old rule\n\
1992 is replaced by the new one."),
1995 add_cmd ("substitute-path", class_files
, unset_substitute_path_command
,
1997 Delete one or all substitution rules rewriting the source directories.\n\
1998 Usage: unset substitute-path [FROM]\n\
1999 Delete the rule for substituting FROM in source directories. If FROM\n\
2000 is not specified, all substituting rules are deleted.\n\
2001 If the debugger cannot find a rule for FROM, it will display a warning."),
2004 add_cmd ("substitute-path", class_files
, show_substitute_path_command
,
2006 Show one or all substitution rules rewriting the source directories.\n\
2007 Usage: show substitute-path [FROM]\n\
2008 Print the rule for substituting FROM in source directories. If FROM\n\
2009 is not specified, print all substitution rules."),
2012 add_setshow_enum_cmd ("filename-display", class_files
,
2013 filename_display_kind_names
,
2014 &filename_display_string
, _("\
2015 Set how to display filenames."), _("\
2016 Show how to display filenames."), _("\
2017 filename-display can be:\n\
2018 basename - display only basename of a filename\n\
2019 relative - display a filename relative to the compilation directory\n\
2020 absolute - display an absolute filename\n\
2021 By default, relative filenames are displayed."),
2023 show_filename_display_string
,
2024 &setlist
, &showlist
);
2026 add_prefix_cmd ("source", no_class
, set_source
,
2027 _("Generic command for setting how sources are handled."),
2028 &setsourcelist
, 0, &setlist
);
2030 add_prefix_cmd ("source", no_class
, show_source
,
2031 _("Generic command for showing source settings."),
2032 &showsourcelist
, 0, &showlist
);
2034 add_setshow_boolean_cmd ("open", class_files
, &source_open
, _("\
2035 Set whether GDB should open source files."), _("\
2036 Show whether GDB should open source files."), _("\
2037 When this option is on GDB will open source files and display the\n\
2038 contents when appropriate, for example, when GDB stops, or the list\n\
2040 When this option is off GDB will not try to open source files, instead\n\
2041 GDB will print the file and line number that would have been displayed.\n\
2042 This can be useful if access to source code files is slow, for example\n\
2043 due to the source being located over a slow network connection."),
2046 &setsourcelist
, &showsourcelist
);