GDB (xrefs)
Loading...
Searching...
No Matches
source.c
Go to the documentation of this file.
1/* List lines of source files for GDB, the GNU debugger.
2 Copyright (C) 1986-2023 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
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.
10
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.
15
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/>. */
18
19#include "defs.h"
20#include "arch-utils.h"
21#include "symtab.h"
22#include "expression.h"
23#include "language.h"
24#include "command.h"
25#include "source.h"
26#include "gdbcmd.h"
27#include "frame.h"
28#include "value.h"
29#include "gdbsupport/filestuff.h"
30
31#include <sys/types.h>
32#include <fcntl.h>
33#include "gdbcore.h"
34#include "gdbsupport/gdb_regex.h"
35#include "symfile.h"
36#include "objfiles.h"
37#include "annotate.h"
38#include "gdbtypes.h"
39#include "linespec.h"
40#include "filenames.h"
41#include "completer.h"
42#include "ui-out.h"
43#include "readline/tilde.h"
44#include "gdbsupport/enum-flags.h"
45#include "gdbsupport/scoped_fd.h"
46#include <algorithm>
47#include "gdbsupport/pathstuff.h"
48#include "source-cache.h"
49#include "cli/cli-style.h"
50#include "observable.h"
51#include "build-id.h"
52#include "debuginfod-support.h"
53#include "gdbsupport/buildargv.h"
54#include "interps.h"
55
56#define OPEN_MODE (O_RDONLY | O_BINARY)
57#define FDOPEN_MODE FOPEN_RB
58
59/* Path of directories to search for source files.
60 Same format as the PATH environment variable's value. */
61
62std::string source_path;
63
64/* Support for source path substitution commands. */
65
67{
68 substitute_path_rule (const char *from_, const char *to_)
69 : from (from_),
70 to (to_)
71 {
72 }
73
74 std::string from;
75 std::string to;
76};
77
78static std::list<substitute_path_rule> substitute_path_rules;
79
80/* An instance of this is attached to each program space. */
81
83{
84public:
85
87
88 /* Set the value. */
89 void set (struct symtab *s, int l)
90 {
91 m_symtab = s;
92 m_line = l;
94 }
95
96 /* Get the symtab. */
97 struct symtab *symtab () const
98 {
99 return m_symtab;
100 }
101
102 /* Get the line number. */
103 int line () const
104 {
105 return m_line;
106 }
107
108private:
109
110 /* Symtab of default file for listing lines of. */
111
112 struct symtab *m_symtab = nullptr;
113
114 /* Default next line to list. */
115
116 int m_line = 0;
117};
118
121
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. */
127
128static int lines_to_list = 10;
129static void
130show_lines_to_list (struct ui_file *file, int from_tty,
131 struct cmd_list_element *c, const char *value)
132{
133 gdb_printf (file,
134 _("Number of source lines gdb "
135 "will list by default is %s.\n"),
136 value);
137}
138
139/* Possible values of 'set filename-display'. */
140static const char filename_display_basename[] = "basename";
141static const char filename_display_relative[] = "relative";
142static const char filename_display_absolute[] = "absolute";
143
150
152
153static void
154show_filename_display_string (struct ui_file *file, int from_tty,
155 struct cmd_list_element *c, const char *value)
156{
157 gdb_printf (file, _("Filenames are displayed as \"%s\".\n"), value);
158}
159
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. */
162
163static bool source_open = true;
164
165/* Implement 'show source open'. */
166
167static void
168show_source_open (struct ui_file *file, int from_tty,
169 struct cmd_list_element *c, const char *value)
170{
171 gdb_printf (file, _("Source opening is \"%s\".\n"), value);
172}
173
174/* Line number of last line printed. Default for various commands.
175 current_source_line is usually, but not always, the same as this. */
176
178
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. */
182
184
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. */
187
188static struct symtab *last_source_visited = NULL;
189static bool last_source_error = false;
190
191/* Return the first line listed by print_source_lines.
192 Used by command interpreters to request listing from
193 a previous point. */
194
195int
197{
198 return first_line_listed;
199}
200
201/* Clear line listed range. This makes the next "list" center the
202 printed source lines around the current source line. */
203
204static void
210
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. */
215
216int
218{
219 return lines_to_list;
220}
221
222/* A helper to return the current source location object for PSPACE,
223 creating it if it does not exist. */
224
227{
229 = current_source_key.get (pspace);
230 if (loc == nullptr)
231 loc = current_source_key.emplace (pspace);
232 return loc;
233}
234
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. */
237
238struct symtab_and_line
240{
241 symtab_and_line cursal;
243
244 cursal.pspace = current_program_space;
245 cursal.symtab = loc->symtab ();
246 cursal.line = loc->line ();
247 cursal.pc = 0;
248 cursal.end = 0;
249
250 return cursal;
251}
252
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. */
260
261void
263{
265 error (_("No symbol table is loaded. Use the \"file\" command."));
266
267 /* Pull in a current source symtab if necessary. */
269 if (loc->symtab () == nullptr)
271}
272
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. */
277
278struct symtab_and_line
280{
281 symtab_and_line cursal;
282
284
285 cursal.pspace = sal.pspace;
286 cursal.symtab = loc->symtab ();
287 cursal.line = loc->line ();
288 cursal.pc = 0;
289 cursal.end = 0;
290
291 loc->set (sal.symtab, sal.line);
292
293 /* Force the next "list" to center around the current line. */
295
296 return cursal;
297}
298
299/* Reset any information stored about a default file and line to print. */
300
301void
307
308/* See source.h. */
309
310void
312{
314 if (loc->symtab () != nullptr)
315 return;
316
317 /* Make the default place to list be the function `main'
318 if one exists. */
320 if (bsym.symbol != nullptr && bsym.symbol->aclass () == LOC_BLOCK)
321 {
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);
327 else
328 loc->set (sal.symtab, std::max (sal.line - (lines_to_list - 1), 1));
329 return;
330 }
331
332 /* Alright; find the last file in the symtab list (ignoring .h's
333 and namespace symtabs). */
334
335 struct symtab *new_symtab = nullptr;
336
337 for (objfile *ofp : current_program_space->objfiles ())
338 {
339 for (compunit_symtab *cu : ofp->compunits ())
340 {
341 for (symtab *symtab : cu->filetabs ())
342 {
343 const char *name = symtab->filename;
344 int len = strlen (name);
345
346 if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
347 || strcmp (name, "<<C++-namespaces>>") == 0)))
349 }
350 }
351 }
352
353 loc->set (new_symtab, 1);
354 if (new_symtab != nullptr)
355 return;
356
358 {
360 if (s)
361 new_symtab = s;
362 }
363 if (new_symtab != nullptr)
364 {
365 loc->set (new_symtab,1);
366 return;
367 }
368
369 error (_("Can't find a default source file"));
370}
371
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. */
375
376static void
377set_directories_command (const char *args,
378 int from_tty, struct cmd_list_element *c)
379{
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;
383
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);
391}
392
393/* Print the list of source directories.
394 This is used by the "ld" command, so it has the signature of a command
395 function. */
396
397static void
398show_directories_1 (ui_file *file, char *ignore, int from_tty)
399{
400 gdb_puts ("Source directories searched: ", file);
401 gdb_puts (source_path.c_str (), file);
402 gdb_puts ("\n", file);
403}
404
405/* Handler for "show directories" command. */
406
407static void
408show_directories_command (struct ui_file *file, int from_tty,
409 struct cmd_list_element *c, const char *value)
410{
411 show_directories_1 (file, NULL, from_tty);
412}
413
414/* See source.h. */
415
416void
418{
419 for (struct program_space *pspace : program_spaces)
420 for (objfile *objfile : pspace->objfiles ())
422
424 last_source_visited = NULL;
425}
426
427void
429{
430 source_path = string_printf ("$cdir%c$cwd", DIRNAME_SEPARATOR);
432}
433
434/* Add zero or more directories to the front of the source path. */
435
436static void
437directory_command (const char *dirname, int from_tty)
438{
439 bool value_changed = false;
440 dont_repeat ();
441 /* FIXME, this goes to "delete dir"... */
442 if (dirname == 0)
443 {
444 if (!from_tty || query (_("Reinitialize source path to empty? ")))
445 {
447 value_changed = true;
448 }
449 }
450 else
451 {
452 mod_path (dirname, source_path);
454 value_changed = true;
455 }
456 if (value_changed)
457 {
458 interps_notify_param_changed ("directories", source_path.c_str ());
459
460 if (from_tty)
461 show_directories_1 (gdb_stdout, (char *) 0, from_tty);
462 }
463}
464
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. */
467
468void
469directory_switch (const char *dirname, int from_tty)
470{
471 add_path (dirname, source_path, 0);
472}
473
474/* Add zero or more directories to the front of an arbitrary path. */
475
476void
477mod_path (const char *dirname, std::string &which_path)
478{
479 add_path (dirname, which_path, 1);
480}
481
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
486 as space or tab. */
487
488void
489add_path (const char *dirname, char **which_path, int parse_separators)
490{
491 char *old = *which_path;
492 int prefix = 0;
493 std::vector<gdb::unique_xmalloc_ptr<char>> dir_vec;
494
495 if (dirname == 0)
496 return;
497
498 if (parse_separators)
499 {
500 /* This will properly parse the space and tab separators
501 and any quotes that may exist. */
502 gdb_argv argv (dirname);
503
504 for (char *arg : argv)
505 dirnames_to_char_ptr_vec_append (&dir_vec, arg);
506 }
507 else
508 dir_vec.emplace_back (xstrdup (dirname));
509
510 for (const gdb::unique_xmalloc_ptr<char> &name_up : dir_vec)
511 {
512 const char *name = name_up.get ();
513 char *p;
514 struct stat st;
515 std::string new_name_holder;
516
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);
521
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:/" */
526#endif
527 && p > name
528 && IS_DIR_SEPARATOR (p[-1]))
529 /* Sigh. "foo/" => "foo" */
530 --p;
531 *p = '\0';
532
533 while (p > name && p[-1] == '.')
534 {
535 if (p - name == 1)
536 {
537 /* "." => getwd (). */
538 name = current_directory;
539 goto append;
540 }
541 else if (p > name + 1 && IS_DIR_SEPARATOR (p[-2]))
542 {
543 if (p - name == 2)
544 {
545 /* "/." => "/". */
546 *--p = '\0';
547 goto append;
548 }
549 else
550 {
551 /* "...foo/." => "...foo". */
552 p -= 2;
553 *p = '\0';
554 continue;
555 }
556 }
557 else
558 break;
559 }
560
561 if (name[0] == '\0')
562 goto skip_dup;
563 if (name[0] == '~')
564 new_name_holder
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) + ".";
569#endif
570 else if (!IS_ABSOLUTE_PATH (name) && name[0] != '$')
571 new_name_holder = gdb_abspath (name);
572 else
573 new_name_holder = std::string (name, p - name);
574
575 name = new_name_holder.c_str ();
576
577 /* Unless it's a variable, check existence. */
578 if (name[0] != '$')
579 {
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.
583
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
588 harmless. */
589 if (stat (name, &st) < 0)
591 else if ((st.st_mode & S_IFMT) != S_IFDIR)
592 warning (_("%ps is not a directory."),
594 }
595
596 append:
597 {
598 unsigned int len = strlen (name);
599 char tinybuf[2];
600
601 p = *which_path;
602 while (1)
603 {
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))
609 {
610 /* Found it in the search path, remove old copy. */
611 if (p > *which_path)
612 {
613 /* Back over leading separator. */
614 p--;
615 }
616 if (prefix > p - *which_path)
617 {
618 /* Same dir twice in one cmd. */
619 goto skip_dup;
620 }
621 /* Copy from next '\0' or ':'. */
622 memmove (p, &p[len + 1], strlen (&p[len + 1]) + 1);
623 }
624 p = strchr (p, DIRNAME_SEPARATOR);
625 if (p != 0)
626 ++p;
627 else
628 break;
629 }
630
631 tinybuf[0] = DIRNAME_SEPARATOR;
632 tinybuf[1] = '\0';
633
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
636 more. */
637 if (prefix)
638 {
639 std::string temp = std::string (old, prefix) + tinybuf + name;
640 *which_path = concat (temp.c_str (), &old[prefix],
641 (char *) nullptr);
642 prefix = temp.length ();
643 }
644 else
645 {
646 *which_path = concat (name, (old[0] ? tinybuf : old),
647 old, (char *)NULL);
648 prefix = strlen (name);
649 }
650 xfree (old);
651 old = *which_path;
652 }
653 skip_dup:
654 ;
655 }
656}
657
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. */
660
661void
662add_path (const char *dirname, std::string &which_path, int parse_separators)
663{
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);
668}
669
670static void
671info_source_command (const char *ignore, int from_tty)
672{
675 struct symtab *s = loc->symtab ();
676 struct compunit_symtab *cust;
677
678 if (!s)
679 {
680 gdb_printf (_("No current source file.\n"));
681 return;
682 }
683
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 ());
688 if (s->fullname)
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");
694
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"));
705}
706
707
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 './'
711 sequences. */
712
713static const char *
715{
716 /* For dos paths, d:/foo -> /foo, and d:foo -> foo. */
717 if (HAS_DRIVE_SPEC (path))
718 path = STRIP_DRIVE_SPEC (path);
719
720 const char *old_path;
721 do
722 {
723 old_path = path;
724
725 /* /foo => foo, to avoid multiple slashes that Emacs doesn't like. */
726 while (IS_DIR_SEPARATOR(path[0]))
727 path++;
728
729 /* ./foo => foo */
730 while (path[0] == '.' && IS_DIR_SEPARATOR (path[1]))
731 path += 2;
732 }
733 while (old_path != path);
734
735 return path;
736}
737
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).
741
742 OPTS specifies the function behaviour in specific cases.
743
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).
750
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
753 executables).
754
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
759 source file name!!!
760
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
764 effect.
765
766 If a file is found, return the descriptor.
767 Otherwise, return -1, with errno set for the last name we tried to open. */
768
769/* >>>> This should only allow files of certain types,
770 >>>> eg executable, non-directory. */
771int
772openp (const char *path, openp_flags opts, const char *string,
773 int mode, gdb::unique_xmalloc_ptr<char> *filename_opened)
774{
775 int fd;
776 char *filename;
777 int alloclen;
778 /* The errno set for the last name we tried to open (and
779 failed). */
780 int last_errno = 0;
781 std::vector<gdb::unique_xmalloc_ptr<char>> dir_vec;
782
783 /* The open syscall MODE parameter is not specified. */
784 gdb_assert ((mode & O_CREAT) == 0);
785 gdb_assert (string != NULL);
786
787 /* A file with an empty name cannot possibly exist. Report a failure
788 without further checking.
789
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')
795 {
796 errno = ENOENT;
797 return -1;
798 }
799
800 if (!path)
801 path = ".";
802
803 mode |= O_BINARY;
804
805 if ((opts & OPF_TRY_CWD_FIRST) || IS_ABSOLUTE_PATH (string))
806 {
807 int i, reg_file_errno;
808
809 if (is_regular_file (string, &reg_file_errno))
810 {
811 filename = (char *) alloca (strlen (string) + 1);
812 strcpy (filename, string);
813 fd = gdb_open_cloexec (filename, mode, 0).release ();
814 if (fd >= 0)
815 goto done;
816 last_errno = errno;
817 }
818 else
819 {
820 filename = NULL;
821 fd = -1;
822 last_errno = reg_file_errno;
823 }
824
825 if (!(opts & OPF_SEARCH_IN_PATH))
826 for (i = 0; string[i]; i++)
827 if (IS_DIR_SEPARATOR (string[i]))
828 goto done;
829 }
830
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);
834
835 alloclen = strlen (path) + strlen (string) + 2;
836 filename = (char *) alloca (alloclen);
837 fd = -1;
838 last_errno = ENOENT;
839
840 dir_vec = dirnames_to_char_ptr_vec (path);
841
842 for (const gdb::unique_xmalloc_ptr<char> &dir_up : dir_vec)
843 {
844 char *dir = dir_up.get ();
845 size_t len = strlen (dir);
846 int reg_file_errno;
847
848 if (strcmp (dir, "$cwd") == 0)
849 {
850 /* Name is $cwd -- insert current directory name instead. */
851 int newlen;
852
853 /* First, realloc the filename buffer if too short. */
854 len = strlen (current_directory);
855 newlen = len + strlen (string) + 2;
856 if (newlen > alloclen)
857 {
858 alloclen = newlen;
859 filename = (char *) alloca (alloclen);
860 }
861 strcpy (filename, current_directory);
862 }
863 else if (strchr(dir, '~'))
864 {
865 /* See whether we need to expand the tilde. */
866 int newlen;
867
868 gdb::unique_xmalloc_ptr<char> tilde_expanded (tilde_expand (dir));
869
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)
874 {
875 alloclen = newlen;
876 filename = (char *) alloca (alloclen);
877 }
878 strcpy (filename, tilde_expanded.get ());
879 }
880 else
881 {
882 /* Normal file name in path -- just use it. */
883 strcpy (filename, dir);
884
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)
893 continue;
894 }
895
896 /* Remove trailing slashes. */
897 while (len > 0 && IS_DIR_SEPARATOR (filename[len - 1]))
898 filename[--len] = 0;
899
900 strcat (filename + len, SLASH_STRING);
901 strcat (filename, string);
902
903 if (is_regular_file (filename, &reg_file_errno))
904 {
905 fd = gdb_open_cloexec (filename, mode, 0).release ();
906 if (fd >= 0)
907 break;
908 last_errno = errno;
909 }
910 else
911 last_errno = reg_file_errno;
912 }
913
914done:
915 if (filename_opened)
916 {
917 /* If a file was opened, canonicalize its filename. */
918 if (fd < 0)
919 filename_opened->reset (NULL);
920 else if ((opts & OPF_RETURN_REALPATH) != 0)
921 *filename_opened = gdb_realpath (filename);
922 else
923 *filename_opened
924 = make_unique_xstrdup (gdb_abspath (filename).c_str ());
925 }
926
927 errno = last_errno;
928 return fd;
929}
930
931
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).
936
937 The current working directory is searched first.
938
939 If the file was found, this function returns 1, and FULL_PATHNAME is
940 set to the fully-qualified pathname.
941
942 Else, this functions returns 0, and FULL_PATHNAME is set to NULL. */
943int
944source_full_path_of (const char *filename,
945 gdb::unique_xmalloc_ptr<char> *full_pathname)
946{
947 int fd;
948
949 fd = openp (source_path.c_str (),
951 filename, O_RDONLY, full_pathname);
952 if (fd < 0)
953 {
954 full_pathname->reset (NULL);
955 return 0;
956 }
957
958 close (fd);
959 return 1;
960}
961
962/* Return non-zero if RULE matches PATH, that is if the rule can be
963 applied to PATH. */
964
965static int
967 const char *path)
968{
969 const int from_len = rule->from.length ();
970 const int path_len = strlen (path);
971
972 if (path_len < from_len)
973 return 0;
974
975 /* The substitution rules are anchored at the start of the path,
976 so the path should start with rule->from. */
977
978 if (filename_ncmp (path, rule->from.c_str (), from_len) != 0)
979 return 0;
980
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). */
984
985 if (path[from_len] != '\0' && !IS_DIR_SEPARATOR (path[from_len]))
986 return 0;
987
988 return 1;
989}
990
991/* Find the substitute-path rule that applies to PATH and return it.
992 Return NULL if no rule applies. */
993
994static struct substitute_path_rule *
995get_substitute_path_rule (const char *path)
996{
998 if (substitute_path_rule_matches (&rule, path))
999 return &rule;
1000
1001 return nullptr;
1002}
1003
1004/* If the user specified a source path substitution rule that applies
1005 to PATH, then apply it and return the new path.
1006
1007 Return NULL if no substitution rule was specified by the user,
1008 or if no rule applied to the given PATH. */
1009
1010gdb::unique_xmalloc_ptr<char>
1011rewrite_source_path (const char *path)
1012{
1013 const struct substitute_path_rule *rule = get_substitute_path_rule (path);
1014
1015 if (rule == nullptr)
1016 return nullptr;
1017
1018 /* Compute the rewritten path and return it. */
1019
1020 return (gdb::unique_xmalloc_ptr<char>
1021 (concat (rule->to.c_str (), path + rule->from.length (), nullptr)));
1022}
1023
1024/* See source.h. */
1025
1026scoped_fd
1027find_and_open_source (const char *filename,
1028 const char *dirname,
1029 gdb::unique_xmalloc_ptr<char> *fullname)
1030{
1031 const char *path = source_path.c_str ();
1032 std::string expanded_path_holder;
1033 const char *p;
1034
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. */
1038 if (!source_open)
1039 return scoped_fd (-ECANCELED);
1040
1041 /* Quick way out if we already know its full name. */
1042 if (*fullname)
1043 {
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 ());
1049
1050 if (rewritten_fullname != NULL)
1051 *fullname = std::move (rewritten_fullname);
1052
1053 scoped_fd result = gdb_open_cloexec (fullname->get (), OPEN_MODE, 0);
1054 if (result.get () >= 0)
1055 {
1056 *fullname = gdb_realpath (fullname->get ());
1057 return result;
1058 }
1059
1060 /* Didn't work -- free old one, try again. */
1061 fullname->reset (NULL);
1062 }
1063
1064 gdb::unique_xmalloc_ptr<char> rewritten_dirname;
1065 if (dirname != NULL)
1066 {
1067 /* If necessary, rewrite the compilation directory name according
1068 to the source path substitution rules specified by the user. */
1069
1070 rewritten_dirname = rewrite_source_path (dirname);
1071
1072 if (rewritten_dirname != NULL)
1073 dirname = rewritten_dirname.get ();
1074
1075 /* Replace a path entry of $cdir with the compilation directory
1076 name. */
1077#define cdir_len 5
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'))
1081 {
1082 int len = p - source_path.c_str ();
1083
1084 /* Before $cdir */
1085 expanded_path_holder = source_path.substr (0, len);
1086
1087 /* new stuff */
1088 expanded_path_holder += dirname;
1089
1090 /* After $cdir */
1091 expanded_path_holder += source_path.c_str () + len + cdir_len;
1092
1093 path = expanded_path_holder.c_str ();
1094 }
1095 }
1096
1097 gdb::unique_xmalloc_ptr<char> rewritten_filename
1098 = rewrite_source_path (filename);
1099
1100 if (rewritten_filename != NULL)
1101 filename = rewritten_filename.get ();
1102
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)
1107 {
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);
1111
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);
1117
1119 cdir_filename.c_str (), OPEN_MODE, fullname);
1120 }
1121 if (result < 0)
1122 {
1123 /* Didn't work. Try using just the basename. */
1124 p = lbasename (filename);
1125 if (p != filename)
1126 result = openp (path, OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH, p,
1127 OPEN_MODE, fullname);
1128 }
1129
1130 /* If the file wasn't found, then openp will have set errno accordingly. */
1131 if (result < 0)
1132 result = -errno;
1133
1134 return scoped_fd (result);
1135}
1136
1137/* Open a source file given a symtab S. Returns a file descriptor or
1138 negative errno for error.
1139
1140 This function is a convenience function to find_and_open_source. */
1141
1142scoped_fd
1144{
1145 if (!s)
1146 return scoped_fd (-EINVAL);
1147
1148 gdb::unique_xmalloc_ptr<char> fullname (s->fullname);
1149 s->fullname = NULL;
1150 scoped_fd fd = find_and_open_source (s->filename, s->compunit ()->dirname (),
1151 &fullname);
1152
1153 if (fd.get () < 0)
1154 {
1155 if (s->compunit () != nullptr)
1156 {
1157 const objfile *ofp = s->compunit ()->objfile ();
1158
1159 std::string srcpath;
1160 if (IS_ABSOLUTE_PATH (s->filename))
1161 srcpath = s->filename;
1162 else if (s->compunit ()->dirname () != nullptr)
1163 {
1164 srcpath = s->compunit ()->dirname ();
1165 srcpath += SLASH_STRING;
1166 srcpath += s->filename;
1167 }
1168
1169 const struct bfd_build_id *build_id
1170 = build_id_bfd_get (ofp->obfd.get ());
1171
1172 /* Query debuginfod for the source file. */
1173 if (build_id != nullptr && !srcpath.empty ())
1174 {
1175 scoped_fd query_fd
1176 = debuginfod_source_query (build_id->data,
1177 build_id->size,
1178 srcpath.c_str (),
1179 &fullname);
1180
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)
1184 {
1185 s->fullname = fullname.release ();
1186 return query_fd;
1187 }
1188 }
1189 }
1190 }
1191
1192 s->fullname = fullname.release ();
1193 return fd;
1194}
1195
1196/* See source.h. */
1197
1198gdb::unique_xmalloc_ptr<char>
1199find_source_or_rewrite (const char *filename, const char *dirname)
1200{
1201 gdb::unique_xmalloc_ptr<char> fullname;
1202
1203 scoped_fd fd = find_and_open_source (filename, dirname, &fullname);
1204 if (fd.get () < 0)
1205 {
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. */
1208
1209 if (dirname == nullptr || IS_ABSOLUTE_PATH (filename))
1210 fullname.reset (xstrdup (filename));
1211 else
1212 fullname.reset (concat (dirname, SLASH_STRING,
1213 filename, (char *) nullptr));
1214
1215 gdb::unique_xmalloc_ptr<char> rewritten
1216 = rewrite_source_path (fullname.get ());
1217 if (rewritten != nullptr)
1218 fullname = std::move (rewritten);
1219 }
1220
1221 return fullname;
1222}
1223
1224/* Finds the fullname that a symtab represents.
1225
1226 This functions finds the fullname and saves it in s->fullname.
1227 It will also return the value.
1228
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
1231 exist. */
1232
1233const char *
1235{
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)
1240 {
1241 scoped_fd fd = open_source_file (s);
1242
1243 if (fd.get () < 0)
1244 {
1245 gdb::unique_xmalloc_ptr<char> fullname;
1246
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. */
1249
1250 if (s->compunit ()->dirname () == nullptr
1251 || IS_ABSOLUTE_PATH (s->filename))
1252 fullname.reset (xstrdup (s->filename));
1253 else
1254 fullname.reset (concat (s->compunit ()->dirname (), SLASH_STRING,
1255 s->filename, (char *) NULL));
1256
1257 s->fullname = rewrite_source_path (fullname.get ()).release ();
1258 if (s->fullname == NULL)
1259 s->fullname = fullname.release ();
1260 }
1261 }
1262
1263 return s->fullname;
1264}
1265
1266/* See commentary in source.h. */
1267
1268const char *
1270{
1272 return lbasename (symtab->filename);
1274 return symtab_to_fullname (symtab);
1276 return symtab->filename;
1277 else
1278 internal_error (_("invalid filename_display_string"));
1279}
1280
1281
1282
1283/* Print source lines from the file of symtab S,
1284 starting with line number LINE and stopping before line number STOPLINE. */
1285
1286static void
1287print_source_lines_base (struct symtab *s, int line, int stopline,
1288 print_source_lines_flags flags)
1289{
1290 bool noprint = false;
1291 int errcode = ENOENT;
1292 int nlines = stopline - line;
1293 struct ui_out *uiout = current_uiout;
1294
1295 /* Regardless of whether we can open the file, set current_source_symtab. */
1298
1299 loc->set (s, line);
1300 first_line_listed = line;
1301 last_line_listed = line;
1302
1303 /* If printing of source lines is disabled, just print file and line
1304 number. */
1305 if (uiout->test_flags (ui_source_list) && source_open)
1306 {
1307 /* Only prints "No such file or directory" once. */
1308 if (s == last_source_visited)
1309 {
1311 {
1313 noprint = true;
1314 }
1315 }
1316 else
1317 {
1319 scoped_fd desc = open_source_file (s);
1320 last_source_error = desc.get () < 0;
1322 {
1323 noprint = true;
1324 errcode = -desc.get ();
1325 }
1326 }
1327 }
1328 else
1329 {
1331 noprint = true;
1332 }
1333
1334 if (noprint)
1335 {
1337 {
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));
1342 }
1343 else
1344 {
1345 uiout->field_signed ("line", line);
1346 uiout->text ("\tin ");
1347
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,
1351 not for TUI. */
1352 if (uiout->is_mi_like_p () || uiout->test_flags (ui_source_list))
1353 uiout->field_string ("file", symtab_to_filename_for_display (s),
1355 if (uiout->is_mi_like_p () || !uiout->test_flags (ui_source_list))
1356 {
1357 const char *s_fullname = symtab_to_fullname (s);
1358 char *local_fullname;
1359
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);
1365
1366 uiout->field_string ("fullname", local_fullname);
1367 }
1368
1369 uiout->text ("\n");
1370 }
1371
1372 return;
1373 }
1374
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)
1378 return;
1379
1380 std::string lines;
1381 if (!g_source_cache.get_source_lines (s, line, stopline - 1, &lines))
1382 {
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."),
1387 offsets == nullptr ? 0 : (int) offsets->size ());
1388 }
1389
1390 const char *iter = lines.c_str ();
1391 int new_lineno = loc->line ();
1392 while (nlines-- > 0 && *iter != '\0')
1393 {
1394 char buf[20];
1395
1396 last_line_listed = loc->line ();
1398 {
1400 uiout->text (":");
1401 }
1402 xsnprintf (buf, sizeof (buf), "%d\t", new_lineno++);
1403 uiout->text (buf);
1404
1405 while (*iter != '\0')
1406 {
1407 /* Find a run of characters that can be emitted at once.
1408 This is done so that escape sequences are kept
1409 together. */
1410 const char *start = iter;
1411 while (true)
1412 {
1413 int skip_bytes;
1414
1415 char c = *iter;
1416 if (c == '\033' && skip_ansi_escape (iter, &skip_bytes))
1417 iter += skip_bytes;
1418 else if (c >= 0 && c < 040 && c != '\t')
1419 break;
1420 else if (c == 0177)
1421 break;
1422 else
1423 ++iter;
1424 }
1425 if (iter > start)
1426 {
1427 std::string text (start, iter);
1428 uiout->text (text);
1429 }
1430 if (*iter == '\r')
1431 {
1432 /* Treat either \r or \r\n as a single newline. */
1433 ++iter;
1434 if (*iter == '\n')
1435 ++iter;
1436 break;
1437 }
1438 else if (*iter == '\n')
1439 {
1440 ++iter;
1441 break;
1442 }
1443 else if (*iter > 0 && *iter < 040)
1444 {
1445 xsnprintf (buf, sizeof (buf), "^%c", *iter + 0100);
1446 uiout->text (buf);
1447 ++iter;
1448 }
1449 else if (*iter == 0177)
1450 {
1451 uiout->text ("^?");
1452 ++iter;
1453 }
1454 }
1455 uiout->text ("\n");
1456 }
1457
1458 loc->set (loc->symtab (), new_lineno);
1459}
1460
1461
1462/* See source.h. */
1463
1464void
1465print_source_lines (struct symtab *s, int line, int stopline,
1466 print_source_lines_flags flags)
1467{
1468 print_source_lines_base (s, line, stopline, flags);
1469}
1470
1471/* See source.h. */
1472
1473void
1475 print_source_lines_flags flags)
1476{
1477 print_source_lines_base (s, line_range.startline (),
1478 line_range.stopline (), flags);
1479}
1480
1481/* See source.h. */
1482
1483int
1485{
1486 const std::vector<off_t> *offsets;
1487
1488 /* Try to get the offsets for the start of each line. */
1489 if (!g_source_cache.get_line_charpos (s, &offsets))
1490 return false;
1491 if (offsets == nullptr)
1492 return false;
1493
1494 return offsets->size ();
1495}
1496
1497
1498
1499/* Print info on range of pc's in a specified line. */
1500
1501static void
1502info_line_command (const char *arg, int from_tty)
1503{
1504 CORE_ADDR start_pc, end_pc;
1505
1506 std::vector<symtab_and_line> decoded_sals;
1507 symtab_and_line curr_sal;
1508 gdb::array_view<symtab_and_line> sals;
1509
1510 if (arg == 0)
1511 {
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;
1518 else
1519 curr_sal.line = loc->line ();
1520
1521 sals = curr_sal;
1522 }
1523 else
1524 {
1525 decoded_sals = decode_line_with_last_displayed (arg,
1527 sals = decoded_sals;
1528
1529 dont_repeat ();
1530 }
1531
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)
1535 {
1536 if (sal.pspace != current_program_space)
1537 continue;
1538
1539 if (sal.symtab == 0)
1540 {
1541 struct gdbarch *gdbarch = get_current_arch ();
1542
1543 gdb_printf (_("No line number information available"));
1544 if (sal.pc != 0)
1545 {
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
1548 address. */
1549 gdb_printf (" for address ");
1550 gdb_stdout->wrap_here (2);
1551 print_address (gdbarch, sal.pc, gdb_stdout);
1552 }
1553 else
1554 gdb_printf (".");
1555 gdb_printf ("\n");
1556 }
1557 else if (sal.line > 0
1558 && find_line_pc_range (sal, &start_pc, &end_pc))
1559 {
1560 gdbarch *gdbarch = sal.symtab->compunit ()->objfile ()->arch ();
1561
1562 if (start_pc == end_pc)
1563 {
1564 gdb_printf ("Line %d of \"%s\"",
1565 sal.line,
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");
1572 }
1573 else
1574 {
1575 gdb_printf ("Line %d of \"%s\"",
1576 sal.line,
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);
1584 gdb_printf (".\n");
1585 }
1586
1587 /* x/i should display this line's code. */
1588 set_next_address (gdbarch, start_pc);
1589
1590 /* Repeating "info line" should do the following line. */
1591 last_line_listed = sal.line + 1;
1592
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);
1597 }
1598 else
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));
1604 }
1605}
1606
1607/* Commands to search the source file for a regexp. */
1608
1609/* Helper for forward_search_command/reverse_search_command. FORWARD
1610 indicates direction: true for forward, false for
1611 backward/reverse. */
1612
1613static void
1614search_command_helper (const char *regex, int from_tty, bool forward)
1615{
1616 const char *msg = re_comp (regex);
1617 if (msg)
1618 error (("%s"), msg);
1619
1622 if (loc->symtab () == nullptr)
1624
1625 if (!source_open)
1626 error (_("source code access disabled"));
1627
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 ()),
1631 -desc.get ());
1632
1633 int line = (forward
1634 ? last_line_listed + 1
1635 : last_line_listed - 1);
1636
1637 const std::vector<off_t> *offsets;
1638 if (line < 1
1639 || !g_source_cache.get_line_charpos (loc->symtab (), &offsets)
1640 || line > offsets->size ())
1641 error (_("Expression not found"));
1642
1643 if (lseek (desc.get (), (*offsets)[line - 1], 0) < 0)
1644 perror_with_name (symtab_to_filename_for_display (loc->symtab ()));
1645
1646 gdb_file_up stream = desc.to_file (FDOPEN_MODE);
1647 clearerr (stream.get ());
1648
1649 gdb::def_vector<char> buf;
1650 buf.reserve (256);
1651
1652 while (1)
1653 {
1654 buf.resize (0);
1655
1656 int c = fgetc (stream.get ());
1657 if (c == EOF)
1658 break;
1659 do
1660 {
1661 buf.push_back (c);
1662 }
1663 while (c != '\n' && (c = fgetc (stream.get ())) >= 0);
1664
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')
1669 {
1670 buf[sz - 2] = '\n';
1671 buf.resize (sz - 1);
1672 }
1673
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)
1677 {
1678 /* Match! */
1679 print_source_lines (loc->symtab (), line, line + 1, 0);
1681 loc->set (loc->symtab (), std::max (line - lines_to_list / 2, 1));
1682 return;
1683 }
1684
1685 if (forward)
1686 line++;
1687 else
1688 {
1689 line--;
1690 if (line < 1)
1691 break;
1692 if (fseek (stream.get (), (*offsets)[line - 1], 0) < 0)
1693 {
1694 const char *filename
1695 = symtab_to_filename_for_display (loc->symtab ());
1696 perror_with_name (filename);
1697 }
1698 }
1699 }
1700
1701 gdb_printf (_("Expression not found\n"));
1702}
1703
1704static void
1705forward_search_command (const char *regex, int from_tty)
1706{
1707 search_command_helper (regex, from_tty, true);
1708}
1709
1710static void
1711reverse_search_command (const char *regex, int from_tty)
1712{
1713 search_command_helper (regex, from_tty, false);
1714}
1715
1716/* If the last character of PATH is a directory separator, then strip it. */
1717
1718static void
1720{
1721 const int last = strlen (path) - 1;
1722
1723 if (last < 0)
1724 return; /* No stripping is needed if PATH is the empty string. */
1725
1726 if (IS_DIR_SEPARATOR (path[last]))
1727 path[last] = '\0';
1728}
1729
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. */
1732
1733void
1734add_substitute_path_rule (const char *from, const char *to)
1735{
1736 substitute_path_rules.emplace_back (from, to);
1737}
1738
1739/* Implement the "show substitute-path" command. */
1740
1741static void
1742show_substitute_path_command (const char *args, int from_tty)
1743{
1744 char *from = NULL;
1745
1746 gdb_argv argv (args);
1747
1748 /* We expect zero or one argument. */
1749
1750 if (argv != NULL && argv[0] != NULL && argv[1] != NULL)
1751 error (_("Too many arguments in command"));
1752
1753 if (argv != NULL && argv[0] != NULL)
1754 from = argv[0];
1755
1756 /* Print the substitution rules. */
1757
1758 if (from != NULL)
1760 (_("Source path substitution rule matching `%s':\n"), from);
1761 else
1762 gdb_printf (_("List of all source path substitution rules:\n"));
1763
1765 {
1766 if (from == NULL || substitute_path_rule_matches (&rule, from) != 0)
1767 gdb_printf (" `%s' -> `%s'.\n", rule.from.c_str (),
1768 rule.to.c_str ());
1769 }
1770}
1771
1772/* Implement the "unset substitute-path" command. */
1773
1774static void
1775unset_substitute_path_command (const char *args, int from_tty)
1776{
1777 gdb_argv argv (args);
1778 char *from = NULL;
1779
1780 /* This function takes either 0 or 1 argument. */
1781
1782 if (argv != NULL && argv[0] != NULL && argv[1] != NULL)
1783 error (_("Incorrect usage, too many arguments in command"));
1784
1785 if (argv != NULL && argv[0] != NULL)
1786 from = argv[0];
1787
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
1790 is performed. */
1791
1792 if (from == NULL
1793 && !query (_("Delete all source path substitution rules? ")))
1794 error (_("Canceled"));
1795
1796 /* Delete the rule matching the argument. No argument means that
1797 all rules should be deleted. */
1798
1799 if (from == nullptr)
1800 substitute_path_rules.clear ();
1801 else
1802 {
1803 auto iter
1804 = std::remove_if (substitute_path_rules.begin (),
1805 substitute_path_rules.end (),
1806 [&] (const substitute_path_rule &rule)
1807 {
1808 return FILENAME_CMP (from,
1809 rule.from.c_str ()) == 0;
1810 });
1811 bool rule_found = iter != substitute_path_rules.end ();
1812 substitute_path_rules.erase (iter, substitute_path_rules.end ());
1813
1814 /* If the user asked for a specific rule to be deleted but
1815 we could not find it, then report an error. */
1816
1817 if (!rule_found)
1818 error (_("No substitution rule defined for `%s'"), from);
1819 }
1820
1822}
1823
1824/* Add a new source path substitution rule. */
1825
1826static void
1827set_substitute_path_command (const char *args, int from_tty)
1828{
1829 gdb_argv argv (args);
1830
1831 if (argv == NULL || argv[0] == NULL || argv [1] == NULL)
1832 error (_("Incorrect usage, too few arguments in command"));
1833
1834 if (argv[2] != NULL)
1835 error (_("Incorrect usage, too many arguments in command"));
1836
1837 if (*(argv[0]) == '\0')
1838 error (_("First argument must be at least one character long"));
1839
1840 /* Strip any trailing directory separator character in either FROM
1841 or TO. The substitution rule already implicitly contains them. */
1844
1845 /* If a rule with the same "from" was previously defined, then
1846 delete it. This new rule replaces it. */
1847
1848 auto iter
1849 = std::remove_if (substitute_path_rules.begin (),
1850 substitute_path_rules.end (),
1851 [&] (const substitute_path_rule &rule)
1852 {
1853 return FILENAME_CMP (argv[0], rule.from.c_str ()) == 0;
1854 });
1855 substitute_path_rules.erase (iter, substitute_path_rules.end ());
1856
1857 /* Insert the new substitution rule. */
1858
1859 add_substitute_path_rule (argv[0], argv[1]);
1861}
1862
1863/* See source.h. */
1864
1867{
1868 if (dir == source_lines_range::FORWARD)
1869 {
1870 LONGEST end = static_cast <LONGEST> (startline) + get_lines_to_list ();
1871
1872 if (end > INT_MAX)
1873 end = INT_MAX;
1874
1876 m_stopline = static_cast <int> (end);
1877 }
1878 else
1879 {
1880 LONGEST start = static_cast <LONGEST> (startline) - get_lines_to_list ();
1881
1882 if (start < 1)
1883 start = 1;
1884
1885 m_startline = static_cast <int> (start);
1887 }
1888}
1889
1890/* Handle the "set source" base command. */
1891
1892static void
1893set_source (const char *arg, int from_tty)
1894{
1896}
1897
1898/* Handle the "show source" base command. */
1899
1900static void
1901show_source (const char *args, int from_tty)
1902{
1903 help_list (showsourcelist, "show source ", all_commands, gdb_stdout);
1904}
1905
1906
1907void _initialize_source ();
1908void
1910{
1912
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);
1918
1919 cmd_list_element *directory_cmd
1920 = add_cmd ("directory", class_files, directory_command, _("\
1921Add directory DIR to beginning of search path for source files.\n\
1922Forget cached info on source file locations and line positions.\n\
1923DIR can also be $cwd for the current working directory, or $cdir for the\n\
1924directory in which the source file was compiled into object code.\n\
1925With no argument, reset the search path to $cdir:$cwd, the default."),
1926 &cmdlist);
1927
1928 set_cmd_completer (directory_cmd, filename_completer);
1929
1930 add_setshow_optional_filename_cmd ("directories",
1932 &source_path,
1933 _("\
1934Set the search path for finding source files."),
1935 _("\
1936Show the search path for finding source files."),
1937 _("\
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\
1940GDB ensures the search path always ends with $cdir:$cwd by\n\
1941appending these directories if necessary.\n\
1942Setting the value to an empty string sets it to $cdir:$cwd, the default."),
1945 &setlist, &showlist);
1946
1947 add_info ("source", info_source_command,
1948 _("Information about the current source file."));
1949
1950 add_info ("line", info_line_command, _("\
1951Core addresses of the code for a source line.\n\
1952Line 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\
1957Default is to describe the last source line that was listed.\n\n\
1958This sets the default address for \"x\" to the line's first instruction\n\
1959so that \"x/i\" suffices to start examining the machine code.\n\
1960The address is also stored as the value of \"$_\"."));
1961
1962 cmd_list_element *forward_search_cmd
1963 = add_com ("forward-search", class_files, forward_search_command, _("\
1964Search for regular expression (see regex(3)) from last line listed.\n\
1965The 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);
1968
1969 cmd_list_element *reverse_search_cmd
1970 = add_com ("reverse-search", class_files, reverse_search_command, _("\
1971Search backward for regular expression (see regex(3)) from last line listed.\n\
1972The matching line number is also stored as the value of \"$_\"."));
1973 add_com_alias ("rev", reverse_search_cmd, class_files, 1);
1974
1976Set number of source lines gdb will list by default."), _("\
1977Show number of source lines gdb will list by default."), _("\
1978Use this to choose how many source lines the \"list\" displays (unless\n\
1979the \"list\" argument explicitly specifies some other number).\n\
1980A value of \"unlimited\", or zero, means there's no limit."),
1981 NULL,
1983 &setlist, &showlist);
1984
1985 add_cmd ("substitute-path", class_files, set_substitute_path_command,
1986 _("\
1987Add a substitution rule to rewrite the source directories.\n\
1988Usage: set substitute-path FROM TO\n\
1989The rule is applied only if the directory name starts with FROM\n\
1990directly followed by a directory separator.\n\
1991If a substitution rule was previously set for FROM, the old rule\n\
1992is replaced by the new one."),
1993 &setlist);
1994
1996 _("\
1997Delete one or all substitution rules rewriting the source directories.\n\
1998Usage: unset substitute-path [FROM]\n\
1999Delete the rule for substituting FROM in source directories. If FROM\n\
2000is not specified, all substituting rules are deleted.\n\
2001If the debugger cannot find a rule for FROM, it will display a warning."),
2002 &unsetlist);
2003
2005 _("\
2006Show one or all substitution rules rewriting the source directories.\n\
2007Usage: show substitute-path [FROM]\n\
2008Print the rule for substituting FROM in source directories. If FROM\n\
2009is not specified, print all substitution rules."),
2010 &showlist);
2011
2012 add_setshow_enum_cmd ("filename-display", class_files,
2015Set how to display filenames."), _("\
2016Show how to display filenames."), _("\
2017filename-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\
2021By default, relative filenames are displayed."),
2022 NULL,
2024 &setlist, &showlist);
2025
2027 _("Generic command for setting how sources are handled."),
2028 &setsourcelist, 0, &setlist);
2029
2031 _("Generic command for showing source settings."),
2032 &showsourcelist, 0, &showlist);
2033
2035Set whether GDB should open source files."), _("\
2036Show whether GDB should open source files."), _("\
2037When this option is on GDB will open source files and display the\n\
2038contents when appropriate, for example, when GDB stops, or the list\n\
2039command is used.\n\
2040When this option is off GDB will not try to open source files, instead\n\
2041GDB will print the file and line number that would have been displayed.\n\
2042This can be useful if access to source code files is slow, for example\n\
2043due to the source being located over a slow network connection."),
2044 NULL,
2047}
const char *const name
void xfree(void *)
bool annotate_source_line(struct symtab *s, int line, int mid_statement, CORE_ADDR pc)
Definition annotate.c:440
struct gdbarch * get_current_arch(void)
Definition arch-utils.c:846
const struct bfd_build_id * build_id_bfd_get(bfd *abfd)
Definition build-id.c:34
ui_file_style style() const
Definition cli-style.c:169
void * get(unsigned key)
Definition registry.h:211
bool get_source_lines(struct symtab *s, int first_line, int last_line, std::string *lines_out)
bool get_line_charpos(struct symtab *s, const std::vector< off_t > **offsets)
int stopline() const
Definition source.h:185
source_lines_range(int startline, direction dir=FORWARD)
Definition source.c:1865
int startline() const
Definition source.h:181
ui_out_flags test_flags(ui_out_flags mask)
Definition ui-out.c:804
void field_string(const char *fldname, const char *string, const ui_file_style &style=ui_file_style())
Definition ui-out.c:511
void field_signed(const char *fldname, LONGEST value)
Definition ui-out.c:437
void text(const char *string)
Definition ui-out.c:566
bool is_mi_like_p() const
Definition ui-out.c:810
struct cmd_list_element * showlist
Definition cli-cmds.c:127
struct cmd_list_element * setsourcelist
Definition cli-cmds.c:173
struct cmd_list_element * cmdlist
Definition cli-cmds.c:87
struct cmd_list_element * setlist
Definition cli-cmds.c:119
struct cmd_list_element * showsourcelist
Definition cli-cmds.c:175
struct cmd_list_element * unsetlist
Definition cli-cmds.c:123
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition cli-decode.c:233
cmd_list_element * add_com_alias(const char *name, cmd_list_element *target, command_class theclass, int abbrev_flag)
set_show_commands add_setshow_optional_filename_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition cli-decode.c:117
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc)
set_show_commands add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:688
set_show_commands add_setshow_integer_cmd(const char *name, enum command_class theclass, int *var, const literal_def *extra_literals, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list)
Definition cli-decode.c:357
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:809
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
cli_style_option file_name_style
void dont_repeat()
Definition top.c:696
@ all_commands
Definition command.h:50
@ class_support
Definition command.h:58
@ class_files
Definition command.h:57
@ no_class
Definition command.h:53
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition completer.c:204
scoped_fd debuginfod_source_query(const unsigned char *build_id, int build_id_len, const char *srcpath, gdb::unique_xmalloc_ptr< char > *destname)
#define O_BINARY
Definition defs.h:114
EXTERN_C char * re_comp(const char *)
void set_next_address(struct gdbarch *, CORE_ADDR)
Definition printcmd.c:532
int annotation_level
Definition stack.c:234
void print_address(struct gdbarch *, CORE_ADDR, struct ui_file *)
Definition printcmd.c:739
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition gnu-nat.c:1861
void interps_notify_param_changed(const char *param, const char *value)
Definition interps.c:563
const char * language_str(enum language lang)
Definition language.c:449
std::vector< symtab_and_line > decode_line_with_last_displayed(const char *string, int flags)
Definition linespec.c:3235
@ DECODE_LINE_LIST_MODE
Definition linespec.h:35
static struct compunit_symtab * new_symtab(const char *, int, struct objfile *)
observable current_source_symtab_and_line_changed
int have_partial_symbols(void)
Definition objfiles.c:763
int have_full_symbols(void)
Definition objfiles.c:778
#define prefix(a, b, R, do)
Definition ppc64-tdep.c:52
struct program_space * current_program_space
Definition progspace.c:40
std::vector< struct program_space * > program_spaces
Definition progspace.c:37
source_cache g_source_cache
int openp(const char *path, openp_flags opts, const char *string, int mode, gdb::unique_xmalloc_ptr< char > *filename_opened)
Definition source.c:772
const char * symtab_to_fullname(struct symtab *s)
Definition source.c:1234
static const char *const filename_display_kind_names[]
Definition source.c:144
static bool source_open
Definition source.c:163
void select_source_symtab()
Definition source.c:311
scoped_fd find_and_open_source(const char *filename, const char *dirname, gdb::unique_xmalloc_ptr< char > *fullname)
Definition source.c:1027
static void show_directories_1(ui_file *file, char *ignore, int from_tty)
Definition source.c:398
static void show_directories_command(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition source.c:408
#define FDOPEN_MODE
Definition source.c:57
const char * symtab_to_filename_for_display(struct symtab *symtab)
Definition source.c:1269
struct symtab_and_line get_current_source_symtab_and_line(void)
Definition source.c:239
static void reverse_search_command(const char *regex, int from_tty)
Definition source.c:1711
static void forward_search_command(const char *regex, int from_tty)
Definition source.c:1705
static void set_substitute_path_command(const char *args, int from_tty)
Definition source.c:1827
static void clear_lines_listed_range(void)
Definition source.c:205
static void strip_trailing_directory_separator(char *path)
Definition source.c:1719
static void show_lines_to_list(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition source.c:130
static void print_source_lines_base(struct symtab *s, int line, int stopline, print_source_lines_flags flags)
Definition source.c:1287
void mod_path(const char *dirname, std::string &which_path)
Definition source.c:477
static void show_source_open(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition source.c:168
void clear_current_source_symtab_and_line(void)
Definition source.c:302
static int last_line_listed
Definition source.c:177
static const char filename_display_absolute[]
Definition source.c:142
int get_first_line_listed(void)
Definition source.c:196
void forget_cached_source_info(void)
Definition source.c:417
void _initialize_source()
Definition source.c:1909
static void directory_command(const char *dirname, int from_tty)
Definition source.c:437
static int first_line_listed
Definition source.c:183
void directory_switch(const char *dirname, int from_tty)
Definition source.c:469
static const char filename_display_basename[]
Definition source.c:140
scoped_fd open_source_file(struct symtab *s)
Definition source.c:1143
void init_source_path(void)
Definition source.c:428
static void show_source(const char *args, int from_tty)
Definition source.c:1901
int last_symtab_line(struct symtab *s)
Definition source.c:1484
static void unset_substitute_path_command(const char *args, int from_tty)
Definition source.c:1775
static const registry< program_space >::key< current_source_location > current_source_key
Definition source.c:120
static void show_substitute_path_command(const char *args, int from_tty)
Definition source.c:1742
static const char * prepare_path_for_appending(const char *path)
Definition source.c:714
static struct symtab * last_source_visited
Definition source.c:188
void add_path(const char *dirname, char **which_path, int parse_separators)
Definition source.c:489
static const char * filename_display_string
Definition source.c:151
void set_default_source_symtab_and_line(void)
Definition source.c:262
void print_source_lines(struct symtab *s, int line, int stopline, print_source_lines_flags flags)
Definition source.c:1465
static current_source_location * get_source_location(program_space *pspace)
Definition source.c:226
gdb::unique_xmalloc_ptr< char > rewrite_source_path(const char *path)
Definition source.c:1011
int get_lines_to_list(void)
Definition source.c:217
gdb::unique_xmalloc_ptr< char > find_source_or_rewrite(const char *filename, const char *dirname)
Definition source.c:1199
static void info_line_command(const char *arg, int from_tty)
Definition source.c:1502
#define OPEN_MODE
Definition source.c:56
struct symtab_and_line set_current_source_symtab_and_line(const symtab_and_line &sal)
Definition source.c:279
std::string source_path
Definition source.c:62
static struct substitute_path_rule * get_substitute_path_rule(const char *path)
Definition source.c:995
int source_full_path_of(const char *filename, gdb::unique_xmalloc_ptr< char > *full_pathname)
Definition source.c:944
static void info_source_command(const char *ignore, int from_tty)
Definition source.c:671
static void search_command_helper(const char *regex, int from_tty, bool forward)
Definition source.c:1614
void add_substitute_path_rule(const char *from, const char *to)
Definition source.c:1734
static int lines_to_list
Definition source.c:128
static int substitute_path_rule_matches(const struct substitute_path_rule *rule, const char *path)
Definition source.c:966
static const char filename_display_relative[]
Definition source.c:141
static void set_directories_command(const char *args, int from_tty, struct cmd_list_element *c)
Definition source.c:377
#define cdir_len
static void set_source(const char *arg, int from_tty)
Definition source.c:1893
static void show_filename_display_string(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition source.c:154
static std::list< substitute_path_rule > substitute_path_rules
Definition source.c:78
static bool last_source_error
Definition source.c:189
int get_lines_to_list(void)
Definition source.c:217
@ OPF_TRY_CWD_FIRST
Definition source.h:30
@ OPF_SEARCH_IN_PATH
Definition source.h:31
@ OPF_RETURN_REALPATH
Definition source.h:32
@ PRINT_SOURCE_LINES_FILENAME
Definition source.h:141
@ PRINT_SOURCE_LINES_NOERROR
Definition source.h:138
struct symbol * symbol
Definition symtab.h:1533
struct macro_table * macro_table() const
Definition symtab.h:1882
const char * debugformat() const
Definition symtab.h:1817
struct objfile * objfile() const
Definition symtab.h:1788
const char * dirname() const
Definition symtab.h:1837
const char * producer() const
Definition symtab.h:1827
void set(struct symtab *s, int l)
Definition source.c:89
current_source_location()=default
struct symtab * symtab() const
Definition source.c:97
struct symtab * m_symtab
Definition source.c:112
void forget_cached_source_info()
struct symtab * find_last_source_symtab()
gdb_bfd_ref_ptr obfd
Definition objfiles.h:740
objfiles_range objfiles()
Definition progspace.h:209
std::string to
Definition source.c:75
std::string from
Definition source.c:74
substitute_path_rule(const char *from_, const char *to_)
Definition source.c:68
address_class aclass() const
Definition symtab.h:1274
struct symtab * symtab
Definition symtab.h:1457
struct symtab * symtab
Definition symtab.h:2328
CORE_ADDR pc
Definition symtab.h:2337
CORE_ADDR end
Definition symtab.h:2338
struct program_space * pspace
Definition symtab.h:2326
enum language language() const
Definition symtab.h:1697
char * fullname
Definition symtab.h:1744
struct compunit_symtab * compunit() const
Definition symtab.h:1677
const char * filename
Definition symtab.h:1725
Definition value.h:130
struct block_symbol lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition symtab.c:1964
bool find_line_pc_range(struct symtab_and_line sal, CORE_ADDR *startptr, CORE_ADDR *endptr)
Definition symtab.c:3499
symtab_and_line find_function_start_sal(CORE_ADDR func_addr, obj_section *section, bool funfirstline)
Definition symtab.c:3639
const char * main_name()
Definition symtab.c:6322
@ LOC_BLOCK
Definition symtab.h:1028
@ VAR_DOMAIN
Definition symtab.h:910
static styled_string_s * styled_string(const ui_file_style &style, const char *str, styled_string_s &&tmp={})
Definition ui-out.h:151
@ ui_source_list
Definition ui-out.h:54
#define current_uiout
Definition ui-out.h:40
bool skip_ansi_escape(const char *buf, int *n_read)
Definition ui-style.c:395
int query(const char *ctlstr,...)
Definition utils.c:943
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition utils.c:1809
void warning_filename_and_errno(const char *filename, int saved_errno)
Definition utils.c:625
#define gdb_stdout
Definition utils.h:182
struct internalvar * lookup_internalvar(const char *name)
Definition value.c:2001
void set_internalvar_integer(struct internalvar *var, LONGEST l)
Definition value.c:2232