1 /* List lines of source files for GDB, the GNU debugger.
2 Copyright (C) 1986-2022 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "arch-utils.h"
22 #include "expression.h"
29 #include "gdbsupport/filestuff.h"
31 #include <sys/types.h>
34 #include "gdbsupport/gdb_regex.h"
40 #include "filenames.h" /* for DOSish file names */
41 #include "completer.h"
43 #include "readline/tilde.h"
44 #include "gdbsupport/enum-flags.h"
45 #include "gdbsupport/scoped_fd.h"
47 #include "gdbsupport/pathstuff.h"
48 #include "source-cache.h"
49 #include "cli/cli-style.h"
50 #include "observable.h"
52 #include "debuginfod-support.h"
53 #include "gdbsupport/buildargv.h"
55 #define OPEN_MODE (O_RDONLY | O_BINARY)
56 #define FDOPEN_MODE FOPEN_RB
58 /* Path of directories to search for source files.
59 Same format as the PATH environment variable's value. */
61 std::string source_path
;
63 /* Support for source path substitution commands. */
65 struct substitute_path_rule
67 substitute_path_rule (const char *from_
, const char *to_
)
77 static std::list
<substitute_path_rule
> substitute_path_rules
;
79 /* An instance of this is attached to each program space. */
81 struct current_source_location
85 current_source_location () = default;
88 void set (struct symtab
*s
, int l
)
92 gdb::observers::current_source_symtab_and_line_changed
.notify ();
96 struct symtab
*symtab () const
101 /* Get the line number. */
109 /* Symtab of default file for listing lines of. */
111 struct symtab
*m_symtab
= nullptr;
113 /* Default next line to list. */
118 static program_space_key
<current_source_location
> current_source_key
;
120 /* Default number of lines to print with commands like "list".
121 This is based on guessing how many long (i.e. more than chars_per_line
122 characters) lines there will be. To be completely correct, "list"
123 and friends should be rewritten to count characters and see where
124 things are wrapping, but that would be a fair amount of work. */
126 static int lines_to_list
= 10;
128 show_lines_to_list (struct ui_file
*file
, int from_tty
,
129 struct cmd_list_element
*c
, const char *value
)
132 _("Number of source lines gdb "
133 "will list by default is %s.\n"),
137 /* Possible values of 'set filename-display'. */
138 static const char filename_display_basename
[] = "basename";
139 static const char filename_display_relative
[] = "relative";
140 static const char filename_display_absolute
[] = "absolute";
142 static const char *const filename_display_kind_names
[] = {
143 filename_display_basename
,
144 filename_display_relative
,
145 filename_display_absolute
,
149 static const char *filename_display_string
= filename_display_relative
;
152 show_filename_display_string (struct ui_file
*file
, int from_tty
,
153 struct cmd_list_element
*c
, const char *value
)
155 gdb_printf (file
, _("Filenames are displayed as \"%s\".\n"), value
);
158 /* When true GDB will stat and open source files as required, but when
159 false, GDB will avoid accessing source files as much as possible. */
161 static bool source_open
= true;
163 /* Implement 'show source open'. */
166 show_source_open (struct ui_file
*file
, int from_tty
,
167 struct cmd_list_element
*c
, const char *value
)
169 gdb_printf (file
, _("Source opening is \"%s\".\n"), value
);
172 /* Line number of last line printed. Default for various commands.
173 current_source_line is usually, but not always, the same as this. */
175 static int last_line_listed
;
177 /* First line number listed by last listing command. If 0, then no
178 source lines have yet been listed since the last time the current
179 source line was changed. */
181 static int first_line_listed
;
183 /* Saves the name of the last source file visited and a possible error code.
184 Used to prevent repeating annoying "No such file or directories" msgs. */
186 static struct symtab
*last_source_visited
= NULL
;
187 static bool last_source_error
= false;
189 /* Return the first line listed by print_source_lines.
190 Used by command interpreters to request listing from
194 get_first_line_listed (void)
196 return first_line_listed
;
199 /* Clear line listed range. This makes the next "list" center the
200 printed source lines around the current source line. */
203 clear_lines_listed_range (void)
205 first_line_listed
= 0;
206 last_line_listed
= 0;
209 /* Return the default number of lines to print with commands like the
210 cli "list". The caller of print_source_lines must use this to
211 calculate the end line and use it in the call to print_source_lines
212 as it does not automatically use this value. */
215 get_lines_to_list (void)
217 return lines_to_list
;
220 /* A helper to return the current source location object for PSPACE,
221 creating it if it does not exist. */
223 static current_source_location
*
224 get_source_location (program_space
*pspace
)
226 current_source_location
*loc
227 = current_source_key
.get (pspace
);
229 loc
= current_source_key
.emplace (pspace
);
233 /* Return the current source file for listing and next line to list.
234 NOTE: The returned sal pc and end fields are not valid. */
236 struct symtab_and_line
237 get_current_source_symtab_and_line (void)
239 symtab_and_line cursal
;
240 current_source_location
*loc
= get_source_location (current_program_space
);
242 cursal
.pspace
= current_program_space
;
243 cursal
.symtab
= loc
->symtab ();
244 cursal
.line
= loc
->line ();
251 /* If the current source file for listing is not set, try and get a default.
252 Usually called before get_current_source_symtab_and_line() is called.
253 It may err out if a default cannot be determined.
254 We must be cautious about where it is called, as it can recurse as the
255 process of determining a new default may call the caller!
256 Use get_current_source_symtab_and_line only to get whatever
257 we have without erroring out or trying to get a default. */
260 set_default_source_symtab_and_line (void)
262 if (!have_full_symbols () && !have_partial_symbols ())
263 error (_("No symbol table is loaded. Use the \"file\" command."));
265 /* Pull in a current source symtab if necessary. */
266 current_source_location
*loc
= get_source_location (current_program_space
);
267 if (loc
->symtab () == nullptr)
268 select_source_symtab (0);
271 /* Return the current default file for listing and next line to list
272 (the returned sal pc and end fields are not valid.)
273 and set the current default to whatever is in SAL.
274 NOTE: The returned sal pc and end fields are not valid. */
276 struct symtab_and_line
277 set_current_source_symtab_and_line (const symtab_and_line
&sal
)
279 symtab_and_line cursal
;
281 current_source_location
*loc
= get_source_location (sal
.pspace
);
283 cursal
.pspace
= sal
.pspace
;
284 cursal
.symtab
= loc
->symtab ();
285 cursal
.line
= loc
->line ();
289 loc
->set (sal
.symtab
, sal
.line
);
291 /* Force the next "list" to center around the current line. */
292 clear_lines_listed_range ();
297 /* Reset any information stored about a default file and line to print. */
300 clear_current_source_symtab_and_line (void)
302 current_source_location
*loc
= get_source_location (current_program_space
);
303 loc
->set (nullptr, 0);
309 select_source_symtab (struct symtab
*s
)
313 current_source_location
*loc
314 = get_source_location (s
->compunit ()->objfile ()->pspace
);
319 current_source_location
*loc
= get_source_location (current_program_space
);
320 if (loc
->symtab () != nullptr)
323 /* Make the default place to list be the function `main'
325 block_symbol bsym
= lookup_symbol (main_name (), 0, VAR_DOMAIN
, 0);
326 if (bsym
.symbol
!= nullptr && bsym
.symbol
->aclass () == LOC_BLOCK
)
328 symtab_and_line sal
= find_function_start_sal (bsym
.symbol
, true);
329 if (sal
.symtab
== NULL
)
330 /* We couldn't find the location of `main', possibly due to missing
331 line number info, fall back to line 1 in the corresponding file. */
332 loc
->set (symbol_symtab (bsym
.symbol
), 1);
334 loc
->set (sal
.symtab
, std::max (sal
.line
- (lines_to_list
- 1), 1));
338 /* Alright; find the last file in the symtab list (ignoring .h's
339 and namespace symtabs). */
341 struct symtab
*new_symtab
= nullptr;
343 for (objfile
*ofp
: current_program_space
->objfiles ())
345 for (compunit_symtab
*cu
: ofp
->compunits ())
347 for (symtab
*symtab
: cu
->filetabs ())
349 const char *name
= symtab
->filename
;
350 int len
= strlen (name
);
352 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
353 || strcmp (name
, "<<C++-namespaces>>") == 0)))
359 loc
->set (new_symtab
, 1);
360 if (new_symtab
!= nullptr)
363 for (objfile
*objfile
: current_program_space
->objfiles ())
365 s
= objfile
->find_last_source_symtab ();
369 if (new_symtab
!= nullptr)
371 loc
->set (new_symtab
,1);
375 error (_("Can't find a default source file"));
378 /* Handler for "set directories path-list" command.
379 "set dir mumble" doesn't prepend paths, it resets the entire
380 path list. The theory is that set(show(dir)) should be a no-op. */
383 set_directories_command (const char *args
,
384 int from_tty
, struct cmd_list_element
*c
)
386 /* This is the value that was set.
387 It needs to be processed to maintain $cdir:$cwd and remove dups. */
388 std::string set_path
= source_path
;
390 /* We preserve the invariant that $cdir:$cwd begins life at the end of
391 the list by calling init_source_path. If they appear earlier in
392 SET_PATH then mod_path will move them appropriately.
393 mod_path will also remove duplicates. */
395 if (!set_path
.empty ())
396 mod_path (set_path
.c_str (), source_path
);
399 /* Print the list of source directories.
400 This is used by the "ld" command, so it has the signature of a command
404 show_directories_1 (ui_file
*file
, char *ignore
, int from_tty
)
406 gdb_puts ("Source directories searched: ", file
);
407 gdb_puts (source_path
.c_str (), file
);
408 gdb_puts ("\n", file
);
411 /* Handler for "show directories" command. */
414 show_directories_command (struct ui_file
*file
, int from_tty
,
415 struct cmd_list_element
*c
, const char *value
)
417 show_directories_1 (file
, NULL
, from_tty
);
423 forget_cached_source_info_for_objfile (struct objfile
*objfile
)
425 for (compunit_symtab
*cu
: objfile
->compunits ())
427 for (symtab
*s
: cu
->filetabs ())
429 if (s
->fullname
!= NULL
)
437 objfile
->forget_cached_source_info ();
443 forget_cached_source_info (void)
445 for (struct program_space
*pspace
: program_spaces
)
446 for (objfile
*objfile
: pspace
->objfiles ())
448 forget_cached_source_info_for_objfile (objfile
);
451 g_source_cache
.clear ();
452 last_source_visited
= NULL
;
456 init_source_path (void)
458 source_path
= string_printf ("$cdir%c$cwd", DIRNAME_SEPARATOR
);
459 forget_cached_source_info ();
462 /* Add zero or more directories to the front of the source path. */
465 directory_command (const char *dirname
, int from_tty
)
467 bool value_changed
= false;
469 /* FIXME, this goes to "delete dir"... */
472 if (!from_tty
|| query (_("Reinitialize source path to empty? ")))
475 value_changed
= true;
480 mod_path (dirname
, source_path
);
481 forget_cached_source_info ();
482 value_changed
= true;
486 gdb::observers::command_param_changed
.notify ("directories",
487 source_path
.c_str ());
489 show_directories_1 (gdb_stdout
, (char *) 0, from_tty
);
493 /* Add a path given with the -d command line switch.
494 This will not be quoted so we must not treat spaces as separators. */
497 directory_switch (const char *dirname
, int from_tty
)
499 add_path (dirname
, source_path
, 0);
502 /* Add zero or more directories to the front of an arbitrary path. */
505 mod_path (const char *dirname
, std::string
&which_path
)
507 add_path (dirname
, which_path
, 1);
510 /* Workhorse of mod_path. Takes an extra argument to determine
511 if dirname should be parsed for separators that indicate multiple
512 directories. This allows for interfaces that pre-parse the dirname
513 and allow specification of traditional separator characters such
517 add_path (const char *dirname
, char **which_path
, int parse_separators
)
519 char *old
= *which_path
;
521 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
;
526 if (parse_separators
)
528 /* This will properly parse the space and tab separators
529 and any quotes that may exist. */
530 gdb_argv
argv (dirname
);
532 for (char *arg
: argv
)
533 dirnames_to_char_ptr_vec_append (&dir_vec
, arg
);
536 dir_vec
.emplace_back (xstrdup (dirname
));
538 for (const gdb::unique_xmalloc_ptr
<char> &name_up
: dir_vec
)
540 char *name
= name_up
.get ();
543 gdb::unique_xmalloc_ptr
<char> new_name_holder
;
545 /* Spaces and tabs will have been removed by buildargv().
546 NAME is the start of the directory.
547 P is the '\0' following the end. */
548 p
= name
+ strlen (name
);
550 while (!(IS_DIR_SEPARATOR (*name
) && p
<= name
+ 1) /* "/" */
551 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
552 /* On MS-DOS and MS-Windows, h:\ is different from h: */
553 && !(p
== name
+ 3 && name
[1] == ':') /* "d:/" */
556 && IS_DIR_SEPARATOR (p
[-1]))
557 /* Sigh. "foo/" => "foo" */
561 while (p
> name
&& p
[-1] == '.')
565 /* "." => getwd (). */
566 name
= current_directory
;
569 else if (p
> name
+ 1 && IS_DIR_SEPARATOR (p
[-2]))
579 /* "...foo/." => "...foo". */
592 new_name_holder
.reset (tilde_expand (name
));
593 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
594 else if (IS_ABSOLUTE_PATH (name
) && p
== name
+ 2) /* "d:" => "d:." */
595 new_name_holder
.reset (concat (name
, ".", (char *) NULL
));
597 else if (!IS_ABSOLUTE_PATH (name
) && name
[0] != '$')
598 new_name_holder
= gdb_abspath (name
);
600 new_name_holder
.reset (savestring (name
, p
- name
));
601 name
= new_name_holder
.get ();
603 /* Unless it's a variable, check existence. */
606 /* These are warnings, not errors, since we don't want a
607 non-existent directory in a .gdbinit file to stop processing
608 of the .gdbinit file.
610 Whether they get added to the path is more debatable. Current
611 answer is yes, in case the user wants to go make the directory
612 or whatever. If the directory continues to not exist/not be
613 a directory/etc, then having them in the path should be
615 if (stat (name
, &st
) < 0)
617 int save_errno
= errno
;
619 gdb_printf (gdb_stderr
, "Warning: ");
620 print_sys_errmsg (name
, save_errno
);
622 else if ((st
.st_mode
& S_IFMT
) != S_IFDIR
)
623 warning (_("%s is not a directory."), name
);
628 unsigned int len
= strlen (name
);
634 /* FIXME: we should use realpath() or its work-alike
635 before comparing. Then all the code above which
636 removes excess slashes and dots could simply go away. */
637 if (!filename_ncmp (p
, name
, len
)
638 && (p
[len
] == '\0' || p
[len
] == DIRNAME_SEPARATOR
))
640 /* Found it in the search path, remove old copy. */
643 /* Back over leading separator. */
646 if (prefix
> p
- *which_path
)
648 /* Same dir twice in one cmd. */
651 /* Copy from next '\0' or ':'. */
652 memmove (p
, &p
[len
+ 1], strlen (&p
[len
+ 1]) + 1);
654 p
= strchr (p
, DIRNAME_SEPARATOR
);
661 tinybuf
[0] = DIRNAME_SEPARATOR
;
664 /* If we have already tacked on a name(s) in this command,
665 be sure they stay on the front as we tack on some
669 std::string temp
= std::string (old
, prefix
) + tinybuf
+ name
;
670 *which_path
= concat (temp
.c_str (), &old
[prefix
],
672 prefix
= temp
.length ();
676 *which_path
= concat (name
, (old
[0] ? tinybuf
: old
),
678 prefix
= strlen (name
);
688 /* add_path would need to be re-written to work on an std::string, but this is
689 not trivial. Hence this overload which copies to a `char *` and back. */
692 add_path (const char *dirname
, std::string
&which_path
, int parse_separators
)
694 char *which_path_copy
= xstrdup (which_path
.data ());
695 add_path (dirname
, &which_path_copy
, parse_separators
);
696 which_path
= which_path_copy
;
697 xfree (which_path_copy
);
701 info_source_command (const char *ignore
, int from_tty
)
703 current_source_location
*loc
704 = get_source_location (current_program_space
);
705 struct symtab
*s
= loc
->symtab ();
706 struct compunit_symtab
*cust
;
710 gdb_printf (_("No current source file.\n"));
714 cust
= s
->compunit ();
715 gdb_printf (_("Current source file is %s\n"), s
->filename
);
716 if (s
->compunit ()->dirname () != NULL
)
717 gdb_printf (_("Compilation directory is %s\n"), s
->compunit ()->dirname ());
719 gdb_printf (_("Located in %s\n"), s
->fullname
);
720 const std::vector
<off_t
> *offsets
;
721 if (g_source_cache
.get_line_charpos (s
, &offsets
))
722 gdb_printf (_("Contains %d line%s.\n"), (int) offsets
->size (),
723 offsets
->size () == 1 ? "" : "s");
725 gdb_printf (_("Source language is %s.\n"),
726 language_str (s
->language ()));
727 gdb_printf (_("Producer is %s.\n"),
728 (cust
->producer ()) != nullptr
729 ? cust
->producer () : _("unknown"));
730 gdb_printf (_("Compiled with %s debugging format.\n"),
731 cust
->debugformat ());
732 gdb_printf (_("%s preprocessor macro info.\n"),
733 (cust
->macro_table () != nullptr
734 ? "Includes" : "Does not include"));
738 /* Helper function to remove characters from the start of PATH so that
739 PATH can then be appended to a directory name. We remove leading drive
740 letters (for dos) as well as leading '/' characters and './'
744 prepare_path_for_appending (const char *path
)
746 /* For dos paths, d:/foo -> /foo, and d:foo -> foo. */
747 if (HAS_DRIVE_SPEC (path
))
748 path
= STRIP_DRIVE_SPEC (path
);
750 const char *old_path
;
755 /* /foo => foo, to avoid multiple slashes that Emacs doesn't like. */
756 while (IS_DIR_SEPARATOR(path
[0]))
760 while (path
[0] == '.' && IS_DIR_SEPARATOR (path
[1]))
763 while (old_path
!= path
);
768 /* Open a file named STRING, searching path PATH (dir names sep by some char)
769 using mode MODE in the calls to open. You cannot use this function to
770 create files (O_CREAT).
772 OPTS specifies the function behaviour in specific cases.
774 If OPF_TRY_CWD_FIRST, try to open ./STRING before searching PATH.
775 (ie pretend the first element of PATH is "."). This also indicates
776 that, unless OPF_SEARCH_IN_PATH is also specified, a slash in STRING
777 disables searching of the path (this is so that "exec-file ./foo" or
778 "symbol-file ./foo" insures that you get that particular version of
779 foo or an error message).
781 If OPTS has OPF_SEARCH_IN_PATH set, absolute names will also be
782 searched in path (we usually want this for source files but not for
785 If FILENAME_OPENED is non-null, set it to a newly allocated string naming
786 the actual file opened (this string will always start with a "/"). We
787 have to take special pains to avoid doubling the "/" between the directory
788 and the file, sigh! Emacs gets confuzzed by this when we print the
791 If OPTS has OPF_RETURN_REALPATH set return FILENAME_OPENED resolved by
792 gdb_realpath. Even without OPF_RETURN_REALPATH this function still returns
793 filename starting with "/". If FILENAME_OPENED is NULL this option has no
796 If a file is found, return the descriptor.
797 Otherwise, return -1, with errno set for the last name we tried to open. */
799 /* >>>> This should only allow files of certain types,
800 >>>> eg executable, non-directory. */
802 openp (const char *path
, openp_flags opts
, const char *string
,
803 int mode
, gdb::unique_xmalloc_ptr
<char> *filename_opened
)
808 /* The errno set for the last name we tried to open (and
811 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
;
813 /* The open syscall MODE parameter is not specified. */
814 gdb_assert ((mode
& O_CREAT
) == 0);
815 gdb_assert (string
!= NULL
);
817 /* A file with an empty name cannot possibly exist. Report a failure
818 without further checking.
820 This is an optimization which also defends us against buggy
821 implementations of the "stat" function. For instance, we have
822 noticed that a MinGW debugger built on Windows XP 32bits crashes
823 when the debugger is started with an empty argument. */
824 if (string
[0] == '\0')
835 if ((opts
& OPF_TRY_CWD_FIRST
) || IS_ABSOLUTE_PATH (string
))
837 int i
, reg_file_errno
;
839 if (is_regular_file (string
, ®_file_errno
))
841 filename
= (char *) alloca (strlen (string
) + 1);
842 strcpy (filename
, string
);
843 fd
= gdb_open_cloexec (filename
, mode
, 0).release ();
852 last_errno
= reg_file_errno
;
855 if (!(opts
& OPF_SEARCH_IN_PATH
))
856 for (i
= 0; string
[i
]; i
++)
857 if (IS_DIR_SEPARATOR (string
[i
]))
861 /* Remove characters from the start of PATH that we don't need when PATH
862 is appended to a directory name. */
863 string
= prepare_path_for_appending (string
);
865 alloclen
= strlen (path
) + strlen (string
) + 2;
866 filename
= (char *) alloca (alloclen
);
870 dir_vec
= dirnames_to_char_ptr_vec (path
);
872 for (const gdb::unique_xmalloc_ptr
<char> &dir_up
: dir_vec
)
874 char *dir
= dir_up
.get ();
875 size_t len
= strlen (dir
);
878 if (strcmp (dir
, "$cwd") == 0)
880 /* Name is $cwd -- insert current directory name instead. */
883 /* First, realloc the filename buffer if too short. */
884 len
= strlen (current_directory
);
885 newlen
= len
+ strlen (string
) + 2;
886 if (newlen
> alloclen
)
889 filename
= (char *) alloca (alloclen
);
891 strcpy (filename
, current_directory
);
893 else if (strchr(dir
, '~'))
895 /* See whether we need to expand the tilde. */
898 gdb::unique_xmalloc_ptr
<char> tilde_expanded (tilde_expand (dir
));
900 /* First, realloc the filename buffer if too short. */
901 len
= strlen (tilde_expanded
.get ());
902 newlen
= len
+ strlen (string
) + 2;
903 if (newlen
> alloclen
)
906 filename
= (char *) alloca (alloclen
);
908 strcpy (filename
, tilde_expanded
.get ());
912 /* Normal file name in path -- just use it. */
913 strcpy (filename
, dir
);
915 /* Don't search $cdir. It's also a magic path like $cwd, but we
916 don't have enough information to expand it. The user *could*
917 have an actual directory named '$cdir' but handling that would
918 be confusing, it would mean different things in different
919 contexts. If the user really has '$cdir' one can use './$cdir'.
920 We can get $cdir when loading scripts. When loading source files
921 $cdir must have already been expanded to the correct value. */
922 if (strcmp (dir
, "$cdir") == 0)
926 /* Remove trailing slashes. */
927 while (len
> 0 && IS_DIR_SEPARATOR (filename
[len
- 1]))
930 strcat (filename
+ len
, SLASH_STRING
);
931 strcat (filename
, string
);
933 if (is_regular_file (filename
, ®_file_errno
))
935 fd
= gdb_open_cloexec (filename
, mode
, 0).release ();
941 last_errno
= reg_file_errno
;
947 /* If a file was opened, canonicalize its filename. */
949 filename_opened
->reset (NULL
);
950 else if ((opts
& OPF_RETURN_REALPATH
) != 0)
951 *filename_opened
= gdb_realpath (filename
);
953 *filename_opened
= gdb_abspath (filename
);
961 /* This is essentially a convenience, for clients that want the behaviour
962 of openp, using source_path, but that really don't want the file to be
963 opened but want instead just to know what the full pathname is (as
964 qualified against source_path).
966 The current working directory is searched first.
968 If the file was found, this function returns 1, and FULL_PATHNAME is
969 set to the fully-qualified pathname.
971 Else, this functions returns 0, and FULL_PATHNAME is set to NULL. */
973 source_full_path_of (const char *filename
,
974 gdb::unique_xmalloc_ptr
<char> *full_pathname
)
978 fd
= openp (source_path
.c_str (),
979 OPF_TRY_CWD_FIRST
| OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
,
980 filename
, O_RDONLY
, full_pathname
);
983 full_pathname
->reset (NULL
);
991 /* Return non-zero if RULE matches PATH, that is if the rule can be
995 substitute_path_rule_matches (const struct substitute_path_rule
*rule
,
998 const int from_len
= rule
->from
.length ();
999 const int path_len
= strlen (path
);
1001 if (path_len
< from_len
)
1004 /* The substitution rules are anchored at the start of the path,
1005 so the path should start with rule->from. */
1007 if (filename_ncmp (path
, rule
->from
.c_str (), from_len
) != 0)
1010 /* Make sure that the region in the path that matches the substitution
1011 rule is immediately followed by a directory separator (or the end of
1012 string character). */
1014 if (path
[from_len
] != '\0' && !IS_DIR_SEPARATOR (path
[from_len
]))
1020 /* Find the substitute-path rule that applies to PATH and return it.
1021 Return NULL if no rule applies. */
1023 static struct substitute_path_rule
*
1024 get_substitute_path_rule (const char *path
)
1026 for (substitute_path_rule
&rule
: substitute_path_rules
)
1027 if (substitute_path_rule_matches (&rule
, path
))
1033 /* If the user specified a source path substitution rule that applies
1034 to PATH, then apply it and return the new path.
1036 Return NULL if no substitution rule was specified by the user,
1037 or if no rule applied to the given PATH. */
1039 gdb::unique_xmalloc_ptr
<char>
1040 rewrite_source_path (const char *path
)
1042 const struct substitute_path_rule
*rule
= get_substitute_path_rule (path
);
1044 if (rule
== nullptr)
1047 /* Compute the rewritten path and return it. */
1049 return (gdb::unique_xmalloc_ptr
<char>
1050 (concat (rule
->to
.c_str (), path
+ rule
->from
.length (), nullptr)));
1056 find_and_open_source (const char *filename
,
1057 const char *dirname
,
1058 gdb::unique_xmalloc_ptr
<char> *fullname
)
1060 const char *path
= source_path
.c_str ();
1061 std::string expanded_path_holder
;
1064 /* If reading of source files is disabled then return a result indicating
1065 the attempt to read this source file failed. GDB will then display
1066 the filename and line number instead. */
1068 return scoped_fd (-1);
1070 /* Quick way out if we already know its full name. */
1073 /* The user may have requested that source paths be rewritten
1074 according to substitution rules he provided. If a substitution
1075 rule applies to this path, then apply it. */
1076 gdb::unique_xmalloc_ptr
<char> rewritten_fullname
1077 = rewrite_source_path (fullname
->get ());
1079 if (rewritten_fullname
!= NULL
)
1080 *fullname
= std::move (rewritten_fullname
);
1082 scoped_fd result
= gdb_open_cloexec (fullname
->get (), OPEN_MODE
, 0);
1083 if (result
.get () >= 0)
1085 *fullname
= gdb_realpath (fullname
->get ());
1089 /* Didn't work -- free old one, try again. */
1090 fullname
->reset (NULL
);
1093 gdb::unique_xmalloc_ptr
<char> rewritten_dirname
;
1094 if (dirname
!= NULL
)
1096 /* If necessary, rewrite the compilation directory name according
1097 to the source path substitution rules specified by the user. */
1099 rewritten_dirname
= rewrite_source_path (dirname
);
1101 if (rewritten_dirname
!= NULL
)
1102 dirname
= rewritten_dirname
.get ();
1104 /* Replace a path entry of $cdir with the compilation directory
1107 p
= strstr (source_path
.c_str (), "$cdir");
1108 if (p
&& (p
== path
|| p
[-1] == DIRNAME_SEPARATOR
)
1109 && (p
[cdir_len
] == DIRNAME_SEPARATOR
|| p
[cdir_len
] == '\0'))
1111 int len
= p
- source_path
.c_str ();
1114 expanded_path_holder
= source_path
.substr (0, len
);
1117 expanded_path_holder
+= dirname
;
1120 expanded_path_holder
+= source_path
.c_str () + len
+ cdir_len
;
1122 path
= expanded_path_holder
.c_str ();
1126 gdb::unique_xmalloc_ptr
<char> rewritten_filename
1127 = rewrite_source_path (filename
);
1129 if (rewritten_filename
!= NULL
)
1130 filename
= rewritten_filename
.get ();
1132 /* Try to locate file using filename. */
1133 int result
= openp (path
, OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
, filename
,
1134 OPEN_MODE
, fullname
);
1135 if (result
< 0 && dirname
!= NULL
)
1137 /* Remove characters from the start of PATH that we don't need when
1138 PATH is appended to a directory name. */
1139 const char *filename_start
= prepare_path_for_appending (filename
);
1141 /* Try to locate file using compilation dir + filename. This is
1142 helpful if part of the compilation directory was removed,
1143 e.g. using gcc's -fdebug-prefix-map, and we have added the missing
1144 prefix to source_path. */
1145 std::string
cdir_filename (dirname
);
1147 /* Remove any trailing directory separators. */
1148 while (IS_DIR_SEPARATOR (cdir_filename
.back ()))
1149 cdir_filename
.pop_back ();
1151 /* Add our own directory separator. */
1152 cdir_filename
.append (SLASH_STRING
);
1153 cdir_filename
.append (filename_start
);
1155 result
= openp (path
, OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
,
1156 cdir_filename
.c_str (), OPEN_MODE
, fullname
);
1160 /* Didn't work. Try using just the basename. */
1161 p
= lbasename (filename
);
1163 result
= openp (path
, OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
, p
,
1164 OPEN_MODE
, fullname
);
1167 return scoped_fd (result
);
1170 /* Open a source file given a symtab S. Returns a file descriptor or
1171 negative number for error.
1173 This function is a convenience function to find_and_open_source. */
1176 open_source_file (struct symtab
*s
)
1179 return scoped_fd (-1);
1181 gdb::unique_xmalloc_ptr
<char> fullname (s
->fullname
);
1183 scoped_fd fd
= find_and_open_source (s
->filename
, s
->compunit ()->dirname (),
1188 if (s
->compunit () != nullptr)
1190 const objfile
*ofp
= s
->compunit ()->objfile ();
1192 std::string srcpath
;
1193 if (IS_ABSOLUTE_PATH (s
->filename
))
1194 srcpath
= s
->filename
;
1195 else if (s
->compunit ()->dirname () != nullptr)
1197 srcpath
= s
->compunit ()->dirname ();
1198 srcpath
+= SLASH_STRING
;
1199 srcpath
+= s
->filename
;
1202 const struct bfd_build_id
*build_id
= build_id_bfd_get (ofp
->obfd
);
1204 /* Query debuginfod for the source file. */
1205 if (build_id
!= nullptr && !srcpath
.empty ())
1206 fd
= debuginfod_source_query (build_id
->data
,
1213 s
->fullname
= fullname
.release ();
1219 gdb::unique_xmalloc_ptr
<char>
1220 find_source_or_rewrite (const char *filename
, const char *dirname
)
1222 gdb::unique_xmalloc_ptr
<char> fullname
;
1224 scoped_fd fd
= find_and_open_source (filename
, dirname
, &fullname
);
1227 /* rewrite_source_path would be applied by find_and_open_source, we
1228 should report the pathname where GDB tried to find the file. */
1230 if (dirname
== nullptr || IS_ABSOLUTE_PATH (filename
))
1231 fullname
.reset (xstrdup (filename
));
1233 fullname
.reset (concat (dirname
, SLASH_STRING
,
1234 filename
, (char *) nullptr));
1236 gdb::unique_xmalloc_ptr
<char> rewritten
1237 = rewrite_source_path (fullname
.get ());
1238 if (rewritten
!= nullptr)
1239 fullname
= std::move (rewritten
);
1245 /* Finds the fullname that a symtab represents.
1247 This functions finds the fullname and saves it in s->fullname.
1248 It will also return the value.
1250 If this function fails to find the file that this symtab represents,
1251 the expected fullname is used. Therefore the files does not have to
1255 symtab_to_fullname (struct symtab
*s
)
1257 /* Use cached copy if we have it.
1258 We rely on forget_cached_source_info being called appropriately
1259 to handle cases like the file being moved. */
1260 if (s
->fullname
== NULL
)
1262 scoped_fd fd
= open_source_file (s
);
1266 gdb::unique_xmalloc_ptr
<char> fullname
;
1268 /* rewrite_source_path would be applied by find_and_open_source, we
1269 should report the pathname where GDB tried to find the file. */
1271 if (s
->compunit ()->dirname () == nullptr
1272 || IS_ABSOLUTE_PATH (s
->filename
))
1273 fullname
.reset (xstrdup (s
->filename
));
1275 fullname
.reset (concat (s
->compunit ()->dirname (), SLASH_STRING
,
1276 s
->filename
, (char *) NULL
));
1278 s
->fullname
= rewrite_source_path (fullname
.get ()).release ();
1279 if (s
->fullname
== NULL
)
1280 s
->fullname
= fullname
.release ();
1287 /* See commentary in source.h. */
1290 symtab_to_filename_for_display (struct symtab
*symtab
)
1292 if (filename_display_string
== filename_display_basename
)
1293 return lbasename (symtab
->filename
);
1294 else if (filename_display_string
== filename_display_absolute
)
1295 return symtab_to_fullname (symtab
);
1296 else if (filename_display_string
== filename_display_relative
)
1297 return symtab
->filename
;
1299 internal_error (__FILE__
, __LINE__
, _("invalid filename_display_string"));
1304 /* Print source lines from the file of symtab S,
1305 starting with line number LINE and stopping before line number STOPLINE. */
1308 print_source_lines_base (struct symtab
*s
, int line
, int stopline
,
1309 print_source_lines_flags flags
)
1311 bool noprint
= false;
1312 int nlines
= stopline
- line
;
1313 struct ui_out
*uiout
= current_uiout
;
1315 /* Regardless of whether we can open the file, set current_source_symtab. */
1316 current_source_location
*loc
1317 = get_source_location (current_program_space
);
1320 first_line_listed
= line
;
1321 last_line_listed
= line
;
1323 /* If printing of source lines is disabled, just print file and line
1325 if (uiout
->test_flags (ui_source_list
) && source_open
)
1327 /* Only prints "No such file or directory" once. */
1328 if (s
== last_source_visited
)
1330 if (last_source_error
)
1332 flags
|= PRINT_SOURCE_LINES_NOERROR
;
1338 last_source_visited
= s
;
1339 scoped_fd desc
= open_source_file (s
);
1340 last_source_error
= desc
.get () < 0;
1341 if (last_source_error
)
1347 flags
|= PRINT_SOURCE_LINES_NOERROR
;
1353 if (!(flags
& PRINT_SOURCE_LINES_NOERROR
))
1355 const char *filename
= symtab_to_filename_for_display (s
);
1356 int len
= strlen (filename
) + 100;
1357 char *name
= (char *) alloca (len
);
1359 xsnprintf (name
, len
, "%d\t%s", line
, filename
);
1360 print_sys_errmsg (name
, errno
);
1364 uiout
->field_signed ("line", line
);
1365 uiout
->text ("\tin ");
1367 /* CLI expects only the "file" field. TUI expects only the
1368 "fullname" field (and TUI does break if "file" is printed).
1369 MI expects both fields. ui_source_list is set only for CLI,
1371 if (uiout
->is_mi_like_p () || uiout
->test_flags (ui_source_list
))
1372 uiout
->field_string ("file", symtab_to_filename_for_display (s
),
1373 file_name_style
.style ());
1374 if (uiout
->is_mi_like_p () || !uiout
->test_flags (ui_source_list
))
1376 const char *s_fullname
= symtab_to_fullname (s
);
1377 char *local_fullname
;
1379 /* ui_out_field_string may free S_FULLNAME by calling
1380 open_source_file for it again. See e.g.,
1381 tui_field_string->tui_show_source. */
1382 local_fullname
= (char *) alloca (strlen (s_fullname
) + 1);
1383 strcpy (local_fullname
, s_fullname
);
1385 uiout
->field_string ("fullname", local_fullname
);
1394 /* If the user requested a sequence of lines that seems to go backward
1395 (from high to low line numbers) then we don't print anything. */
1396 if (stopline
<= line
)
1400 if (!g_source_cache
.get_source_lines (s
, line
, stopline
- 1, &lines
))
1402 const std::vector
<off_t
> *offsets
= nullptr;
1403 g_source_cache
.get_line_charpos (s
, &offsets
);
1404 error (_("Line number %d out of range; %s has %d lines."),
1405 line
, symtab_to_filename_for_display (s
),
1406 offsets
== nullptr ? 0 : (int) offsets
->size ());
1409 const char *iter
= lines
.c_str ();
1410 int new_lineno
= loc
->line ();
1411 while (nlines
-- > 0 && *iter
!= '\0')
1415 last_line_listed
= loc
->line ();
1416 if (flags
& PRINT_SOURCE_LINES_FILENAME
)
1418 uiout
->text (symtab_to_filename_for_display (s
));
1421 xsnprintf (buf
, sizeof (buf
), "%d\t", new_lineno
++);
1424 while (*iter
!= '\0')
1426 /* Find a run of characters that can be emitted at once.
1427 This is done so that escape sequences are kept
1429 const char *start
= iter
;
1435 if (c
== '\033' && skip_ansi_escape (iter
, &skip_bytes
))
1437 else if (c
>= 0 && c
< 040 && c
!= '\t')
1446 std::string
text (start
, iter
);
1451 /* Treat either \r or \r\n as a single newline. */
1457 else if (*iter
== '\n')
1462 else if (*iter
> 0 && *iter
< 040)
1464 xsnprintf (buf
, sizeof (buf
), "^%c", *iter
+ 0100);
1468 else if (*iter
== 0177)
1477 loc
->set (loc
->symtab (), new_lineno
);
1484 print_source_lines (struct symtab
*s
, int line
, int stopline
,
1485 print_source_lines_flags flags
)
1487 print_source_lines_base (s
, line
, stopline
, flags
);
1493 print_source_lines (struct symtab
*s
, source_lines_range line_range
,
1494 print_source_lines_flags flags
)
1496 print_source_lines_base (s
, line_range
.startline (),
1497 line_range
.stopline (), flags
);
1502 /* Print info on range of pc's in a specified line. */
1505 info_line_command (const char *arg
, int from_tty
)
1507 CORE_ADDR start_pc
, end_pc
;
1509 std::vector
<symtab_and_line
> decoded_sals
;
1510 symtab_and_line curr_sal
;
1511 gdb::array_view
<symtab_and_line
> sals
;
1515 current_source_location
*loc
1516 = get_source_location (current_program_space
);
1517 curr_sal
.symtab
= loc
->symtab ();
1518 curr_sal
.pspace
= current_program_space
;
1519 if (last_line_listed
!= 0)
1520 curr_sal
.line
= last_line_listed
;
1522 curr_sal
.line
= loc
->line ();
1528 decoded_sals
= decode_line_with_last_displayed (arg
,
1529 DECODE_LINE_LIST_MODE
);
1530 sals
= decoded_sals
;
1535 /* C++ More than one line may have been specified, as when the user
1536 specifies an overloaded function name. Print info on them all. */
1537 for (const auto &sal
: sals
)
1539 if (sal
.pspace
!= current_program_space
)
1542 if (sal
.symtab
== 0)
1544 struct gdbarch
*gdbarch
= get_current_arch ();
1546 gdb_printf (_("No line number information available"));
1549 /* This is useful for "info line *0x7f34". If we can't tell the
1550 user about a source line, at least let them have the symbolic
1552 gdb_printf (" for address ");
1553 gdb_stdout
->wrap_here (2);
1554 print_address (gdbarch
, sal
.pc
, gdb_stdout
);
1560 else if (sal
.line
> 0
1561 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
1563 gdbarch
*gdbarch
= sal
.symtab
->compunit ()->objfile ()->arch ();
1565 if (start_pc
== end_pc
)
1567 gdb_printf ("Line %d of \"%s\"",
1569 symtab_to_filename_for_display (sal
.symtab
));
1570 gdb_stdout
->wrap_here (2);
1571 gdb_printf (" is at address ");
1572 print_address (gdbarch
, start_pc
, gdb_stdout
);
1573 gdb_stdout
->wrap_here (2);
1574 gdb_printf (" but contains no code.\n");
1578 gdb_printf ("Line %d of \"%s\"",
1580 symtab_to_filename_for_display (sal
.symtab
));
1581 gdb_stdout
->wrap_here (2);
1582 gdb_printf (" starts at address ");
1583 print_address (gdbarch
, start_pc
, gdb_stdout
);
1584 gdb_stdout
->wrap_here (2);
1585 gdb_printf (" and ends at ");
1586 print_address (gdbarch
, end_pc
, gdb_stdout
);
1590 /* x/i should display this line's code. */
1591 set_next_address (gdbarch
, start_pc
);
1593 /* Repeating "info line" should do the following line. */
1594 last_line_listed
= sal
.line
+ 1;
1596 /* If this is the only line, show the source code. If it could
1597 not find the file, don't do anything special. */
1598 if (annotation_level
> 0 && sals
.size () == 1)
1599 annotate_source_line (sal
.symtab
, sal
.line
, 0, start_pc
);
1602 /* Is there any case in which we get here, and have an address
1603 which the user would want to see? If we have debugging symbols
1604 and no line numbers? */
1605 gdb_printf (_("Line number %d is out of range for \"%s\".\n"),
1606 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
1610 /* Commands to search the source file for a regexp. */
1612 /* Helper for forward_search_command/reverse_search_command. FORWARD
1613 indicates direction: true for forward, false for
1614 backward/reverse. */
1617 search_command_helper (const char *regex
, int from_tty
, bool forward
)
1619 const char *msg
= re_comp (regex
);
1621 error (("%s"), msg
);
1623 current_source_location
*loc
1624 = get_source_location (current_program_space
);
1625 if (loc
->symtab () == nullptr)
1626 select_source_symtab (0);
1629 error (_("source code access disabled"));
1631 scoped_fd
desc (open_source_file (loc
->symtab ()));
1632 if (desc
.get () < 0)
1633 perror_with_name (symtab_to_filename_for_display (loc
->symtab ()));
1636 ? last_line_listed
+ 1
1637 : last_line_listed
- 1);
1639 const std::vector
<off_t
> *offsets
;
1641 || !g_source_cache
.get_line_charpos (loc
->symtab (), &offsets
)
1642 || line
> offsets
->size ())
1643 error (_("Expression not found"));
1645 if (lseek (desc
.get (), (*offsets
)[line
- 1], 0) < 0)
1646 perror_with_name (symtab_to_filename_for_display (loc
->symtab ()));
1648 gdb_file_up stream
= desc
.to_file (FDOPEN_MODE
);
1649 clearerr (stream
.get ());
1651 gdb::def_vector
<char> buf
;
1658 int c
= fgetc (stream
.get ());
1665 while (c
!= '\n' && (c
= fgetc (stream
.get ())) >= 0);
1667 /* Remove the \r, if any, at the end of the line, otherwise
1668 regular expressions that end with $ or \n won't work. */
1669 size_t sz
= buf
.size ();
1670 if (sz
>= 2 && buf
[sz
- 2] == '\r')
1673 buf
.resize (sz
- 1);
1676 /* We now have a source line in buf, null terminate and match. */
1677 buf
.push_back ('\0');
1678 if (re_exec (buf
.data ()) > 0)
1681 print_source_lines (loc
->symtab (), line
, line
+ 1, 0);
1682 set_internalvar_integer (lookup_internalvar ("_"), line
);
1683 loc
->set (loc
->symtab (), std::max (line
- lines_to_list
/ 2, 1));
1694 if (fseek (stream
.get (), (*offsets
)[line
- 1], 0) < 0)
1696 const char *filename
1697 = symtab_to_filename_for_display (loc
->symtab ());
1698 perror_with_name (filename
);
1703 gdb_printf (_("Expression not found\n"));
1707 forward_search_command (const char *regex
, int from_tty
)
1709 search_command_helper (regex
, from_tty
, true);
1713 reverse_search_command (const char *regex
, int from_tty
)
1715 search_command_helper (regex
, from_tty
, false);
1718 /* If the last character of PATH is a directory separator, then strip it. */
1721 strip_trailing_directory_separator (char *path
)
1723 const int last
= strlen (path
) - 1;
1726 return; /* No stripping is needed if PATH is the empty string. */
1728 if (IS_DIR_SEPARATOR (path
[last
]))
1732 /* Add a new substitute-path rule at the end of the current list of rules.
1733 The new rule will replace FROM into TO. */
1736 add_substitute_path_rule (const char *from
, const char *to
)
1738 substitute_path_rules
.emplace_back (from
, to
);
1741 /* Implement the "show substitute-path" command. */
1744 show_substitute_path_command (const char *args
, int from_tty
)
1748 gdb_argv
argv (args
);
1750 /* We expect zero or one argument. */
1752 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1753 error (_("Too many arguments in command"));
1755 if (argv
!= NULL
&& argv
[0] != NULL
)
1758 /* Print the substitution rules. */
1762 (_("Source path substitution rule matching `%s':\n"), from
);
1764 gdb_printf (_("List of all source path substitution rules:\n"));
1766 for (substitute_path_rule
&rule
: substitute_path_rules
)
1768 if (from
== NULL
|| substitute_path_rule_matches (&rule
, from
) != 0)
1769 gdb_printf (" `%s' -> `%s'.\n", rule
.from
.c_str (),
1774 /* Implement the "unset substitute-path" command. */
1777 unset_substitute_path_command (const char *args
, int from_tty
)
1779 gdb_argv
argv (args
);
1782 /* This function takes either 0 or 1 argument. */
1784 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1785 error (_("Incorrect usage, too many arguments in command"));
1787 if (argv
!= NULL
&& argv
[0] != NULL
)
1790 /* If the user asked for all the rules to be deleted, ask him
1791 to confirm and give him a chance to abort before the action
1795 && !query (_("Delete all source path substitution rules? ")))
1796 error (_("Canceled"));
1798 /* Delete the rule matching the argument. No argument means that
1799 all rules should be deleted. */
1801 if (from
== nullptr)
1802 substitute_path_rules
.clear ();
1806 = std::remove_if (substitute_path_rules
.begin (),
1807 substitute_path_rules
.end (),
1808 [&] (const substitute_path_rule
&rule
)
1810 return FILENAME_CMP (from
,
1811 rule
.from
.c_str ()) == 0;
1813 bool rule_found
= iter
!= substitute_path_rules
.end ();
1814 substitute_path_rules
.erase (iter
, substitute_path_rules
.end ());
1816 /* If the user asked for a specific rule to be deleted but
1817 we could not find it, then report an error. */
1820 error (_("No substitution rule defined for `%s'"), from
);
1823 forget_cached_source_info ();
1826 /* Add a new source path substitution rule. */
1829 set_substitute_path_command (const char *args
, int from_tty
)
1831 gdb_argv
argv (args
);
1833 if (argv
== NULL
|| argv
[0] == NULL
|| argv
[1] == NULL
)
1834 error (_("Incorrect usage, too few arguments in command"));
1836 if (argv
[2] != NULL
)
1837 error (_("Incorrect usage, too many arguments in command"));
1839 if (*(argv
[0]) == '\0')
1840 error (_("First argument must be at least one character long"));
1842 /* Strip any trailing directory separator character in either FROM
1843 or TO. The substitution rule already implicitly contains them. */
1844 strip_trailing_directory_separator (argv
[0]);
1845 strip_trailing_directory_separator (argv
[1]);
1847 /* If a rule with the same "from" was previously defined, then
1848 delete it. This new rule replaces it. */
1851 = std::remove_if (substitute_path_rules
.begin (),
1852 substitute_path_rules
.end (),
1853 [&] (const substitute_path_rule
&rule
)
1855 return FILENAME_CMP (argv
[0], rule
.from
.c_str ()) == 0;
1857 substitute_path_rules
.erase (iter
, substitute_path_rules
.end ());
1859 /* Insert the new substitution rule. */
1861 add_substitute_path_rule (argv
[0], argv
[1]);
1862 forget_cached_source_info ();
1867 source_lines_range::source_lines_range (int startline
,
1868 source_lines_range::direction dir
)
1870 if (dir
== source_lines_range::FORWARD
)
1872 LONGEST end
= static_cast <LONGEST
> (startline
) + get_lines_to_list ();
1877 m_startline
= startline
;
1878 m_stopline
= static_cast <int> (end
);
1882 LONGEST start
= static_cast <LONGEST
> (startline
) - get_lines_to_list ();
1887 m_startline
= static_cast <int> (start
);
1888 m_stopline
= startline
;
1892 /* Handle the "set source" base command. */
1895 set_source (const char *arg
, int from_tty
)
1897 help_list (setsourcelist
, "set source ", all_commands
, gdb_stdout
);
1900 /* Handle the "show source" base command. */
1903 show_source (const char *args
, int from_tty
)
1905 help_list (showsourcelist
, "show source ", all_commands
, gdb_stdout
);
1909 void _initialize_source ();
1911 _initialize_source ()
1913 init_source_path ();
1915 /* The intention is to use POSIX Basic Regular Expressions.
1916 Always use the GNU regex routine for consistency across all hosts.
1917 Our current GNU regex.c does not have all the POSIX features, so this is
1918 just an approximation. */
1919 re_set_syntax (RE_SYNTAX_GREP
);
1921 cmd_list_element
*directory_cmd
1922 = add_cmd ("directory", class_files
, directory_command
, _("\
1923 Add directory DIR to beginning of search path for source files.\n\
1924 Forget cached info on source file locations and line positions.\n\
1925 DIR can also be $cwd for the current working directory, or $cdir for the\n\
1926 directory in which the source file was compiled into object code.\n\
1927 With no argument, reset the search path to $cdir:$cwd, the default."),
1930 set_cmd_completer (directory_cmd
, filename_completer
);
1932 add_setshow_optional_filename_cmd ("directories",
1936 Set the search path for finding source files."),
1938 Show the search path for finding source files."),
1940 $cwd in the path means the current working directory.\n\
1941 $cdir in the path means the compilation directory of the source file.\n\
1942 GDB ensures the search path always ends with $cdir:$cwd by\n\
1943 appending these directories if necessary.\n\
1944 Setting the value to an empty string sets it to $cdir:$cwd, the default."),
1945 set_directories_command
,
1946 show_directories_command
,
1947 &setlist
, &showlist
);
1949 add_info ("source", info_source_command
,
1950 _("Information about the current source file."));
1952 add_info ("line", info_line_command
, _("\
1953 Core addresses of the code for a source line.\n\
1954 Line can be specified as\n\
1955 LINENUM, to list around that line in current file,\n\
1956 FILE:LINENUM, to list around that line in that file,\n\
1957 FUNCTION, to list around beginning of that function,\n\
1958 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1959 Default is to describe the last source line that was listed.\n\n\
1960 This sets the default address for \"x\" to the line's first instruction\n\
1961 so that \"x/i\" suffices to start examining the machine code.\n\
1962 The address is also stored as the value of \"$_\"."));
1964 cmd_list_element
*forward_search_cmd
1965 = add_com ("forward-search", class_files
, forward_search_command
, _("\
1966 Search for regular expression (see regex(3)) from last line listed.\n\
1967 The matching line number is also stored as the value of \"$_\"."));
1968 add_com_alias ("search", forward_search_cmd
, class_files
, 0);
1969 add_com_alias ("fo", forward_search_cmd
, class_files
, 1);
1971 cmd_list_element
*reverse_search_cmd
1972 = add_com ("reverse-search", class_files
, reverse_search_command
, _("\
1973 Search backward for regular expression (see regex(3)) from last line listed.\n\
1974 The matching line number is also stored as the value of \"$_\"."));
1975 add_com_alias ("rev", reverse_search_cmd
, class_files
, 1);
1977 add_setshow_integer_cmd ("listsize", class_support
, &lines_to_list
, _("\
1978 Set number of source lines gdb will list by default."), _("\
1979 Show number of source lines gdb will list by default."), _("\
1980 Use this to choose how many source lines the \"list\" displays (unless\n\
1981 the \"list\" argument explicitly specifies some other number).\n\
1982 A value of \"unlimited\", or zero, means there's no limit."),
1985 &setlist
, &showlist
);
1987 add_cmd ("substitute-path", class_files
, set_substitute_path_command
,
1989 Add a substitution rule to rewrite the source directories.\n\
1990 Usage: set substitute-path FROM TO\n\
1991 The rule is applied only if the directory name starts with FROM\n\
1992 directly followed by a directory separator.\n\
1993 If a substitution rule was previously set for FROM, the old rule\n\
1994 is replaced by the new one."),
1997 add_cmd ("substitute-path", class_files
, unset_substitute_path_command
,
1999 Delete one or all substitution rules rewriting the source directories.\n\
2000 Usage: unset substitute-path [FROM]\n\
2001 Delete the rule for substituting FROM in source directories. If FROM\n\
2002 is not specified, all substituting rules are deleted.\n\
2003 If the debugger cannot find a rule for FROM, it will display a warning."),
2006 add_cmd ("substitute-path", class_files
, show_substitute_path_command
,
2008 Show one or all substitution rules rewriting the source directories.\n\
2009 Usage: show substitute-path [FROM]\n\
2010 Print the rule for substituting FROM in source directories. If FROM\n\
2011 is not specified, print all substitution rules."),
2014 add_setshow_enum_cmd ("filename-display", class_files
,
2015 filename_display_kind_names
,
2016 &filename_display_string
, _("\
2017 Set how to display filenames."), _("\
2018 Show how to display filenames."), _("\
2019 filename-display can be:\n\
2020 basename - display only basename of a filename\n\
2021 relative - display a filename relative to the compilation directory\n\
2022 absolute - display an absolute filename\n\
2023 By default, relative filenames are displayed."),
2025 show_filename_display_string
,
2026 &setlist
, &showlist
);
2028 add_prefix_cmd ("source", no_class
, set_source
,
2029 _("Generic command for setting how sources are handled."),
2030 &setsourcelist
, 0, &setlist
);
2032 add_prefix_cmd ("source", no_class
, show_source
,
2033 _("Generic command for showing source settings."),
2034 &showsourcelist
, 0, &showlist
);
2036 add_setshow_boolean_cmd ("open", class_files
, &source_open
, _("\
2037 Set whether GDB should open source files."), _("\
2038 Show whether GDB should open source files."), _("\
2039 When this option is on GDB will open source files and display the\n\
2040 contents when appropriate, for example, when GDB stops, or the list\n\
2042 When this option is off GDB will not try to open source files, instead\n\
2043 GDB will print the file and line number that would have been displayed.\n\
2044 This can be useful if access to source code files is slow, for example\n\
2045 due to the source being located over a slow network connection."),
2048 &setsourcelist
, &showsourcelist
);