Introduce find_source_or_rewrite
[binutils-gdb.git] / gdb / source.c
1 /* List lines of source files for GDB, the GNU debugger.
2 Copyright (C) 1986-2021 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 "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" /* for DOSish file names */
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
54 #define OPEN_MODE (O_RDONLY | O_BINARY)
55 #define FDOPEN_MODE FOPEN_RB
56
57 /* Path of directories to search for source files.
58 Same format as the PATH environment variable's value. */
59
60 char *source_path;
61
62 /* Support for source path substitution commands. */
63
64 struct substitute_path_rule
65 {
66 char *from;
67 char *to;
68 struct substitute_path_rule *next;
69 };
70
71 static struct substitute_path_rule *substitute_path_rules = NULL;
72
73 /* An instance of this is attached to each program space. */
74
75 struct current_source_location
76 {
77 public:
78
79 current_source_location () = default;
80
81 /* Set the value. */
82 void set (struct symtab *s, int l)
83 {
84 m_symtab = s;
85 m_line = l;
86 gdb::observers::current_source_symtab_and_line_changed.notify ();
87 }
88
89 /* Get the symtab. */
90 struct symtab *symtab () const
91 {
92 return m_symtab;
93 }
94
95 /* Get the line number. */
96 int line () const
97 {
98 return m_line;
99 }
100
101 private:
102
103 /* Symtab of default file for listing lines of. */
104
105 struct symtab *m_symtab = nullptr;
106
107 /* Default next line to list. */
108
109 int m_line = 0;
110 };
111
112 static program_space_key<current_source_location> current_source_key;
113
114 /* Default number of lines to print with commands like "list".
115 This is based on guessing how many long (i.e. more than chars_per_line
116 characters) lines there will be. To be completely correct, "list"
117 and friends should be rewritten to count characters and see where
118 things are wrapping, but that would be a fair amount of work. */
119
120 static int lines_to_list = 10;
121 static void
122 show_lines_to_list (struct ui_file *file, int from_tty,
123 struct cmd_list_element *c, const char *value)
124 {
125 fprintf_filtered (file,
126 _("Number of source lines gdb "
127 "will list by default is %s.\n"),
128 value);
129 }
130
131 /* Possible values of 'set filename-display'. */
132 static const char filename_display_basename[] = "basename";
133 static const char filename_display_relative[] = "relative";
134 static const char filename_display_absolute[] = "absolute";
135
136 static const char *const filename_display_kind_names[] = {
137 filename_display_basename,
138 filename_display_relative,
139 filename_display_absolute,
140 NULL
141 };
142
143 static const char *filename_display_string = filename_display_relative;
144
145 static void
146 show_filename_display_string (struct ui_file *file, int from_tty,
147 struct cmd_list_element *c, const char *value)
148 {
149 fprintf_filtered (file, _("Filenames are displayed as \"%s\".\n"), value);
150 }
151
152 /* Line number of last line printed. Default for various commands.
153 current_source_line is usually, but not always, the same as this. */
154
155 static int last_line_listed;
156
157 /* First line number listed by last listing command. If 0, then no
158 source lines have yet been listed since the last time the current
159 source line was changed. */
160
161 static int first_line_listed;
162
163 /* Saves the name of the last source file visited and a possible error code.
164 Used to prevent repeating annoying "No such file or directories" msgs. */
165
166 static struct symtab *last_source_visited = NULL;
167 static bool last_source_error = false;
168 \f
169 /* Return the first line listed by print_source_lines.
170 Used by command interpreters to request listing from
171 a previous point. */
172
173 int
174 get_first_line_listed (void)
175 {
176 return first_line_listed;
177 }
178
179 /* Clear line listed range. This makes the next "list" center the
180 printed source lines around the current source line. */
181
182 static void
183 clear_lines_listed_range (void)
184 {
185 first_line_listed = 0;
186 last_line_listed = 0;
187 }
188
189 /* Return the default number of lines to print with commands like the
190 cli "list". The caller of print_source_lines must use this to
191 calculate the end line and use it in the call to print_source_lines
192 as it does not automatically use this value. */
193
194 int
195 get_lines_to_list (void)
196 {
197 return lines_to_list;
198 }
199
200 /* A helper to return the current source location object for PSPACE,
201 creating it if it does not exist. */
202
203 static current_source_location *
204 get_source_location (program_space *pspace)
205 {
206 current_source_location *loc
207 = current_source_key.get (pspace);
208 if (loc == nullptr)
209 loc = current_source_key.emplace (pspace);
210 return loc;
211 }
212
213 /* Return the current source file for listing and next line to list.
214 NOTE: The returned sal pc and end fields are not valid. */
215
216 struct symtab_and_line
217 get_current_source_symtab_and_line (void)
218 {
219 symtab_and_line cursal;
220 current_source_location *loc = get_source_location (current_program_space);
221
222 cursal.pspace = current_program_space;
223 cursal.symtab = loc->symtab ();
224 cursal.line = loc->line ();
225 cursal.pc = 0;
226 cursal.end = 0;
227
228 return cursal;
229 }
230
231 /* If the current source file for listing is not set, try and get a default.
232 Usually called before get_current_source_symtab_and_line() is called.
233 It may err out if a default cannot be determined.
234 We must be cautious about where it is called, as it can recurse as the
235 process of determining a new default may call the caller!
236 Use get_current_source_symtab_and_line only to get whatever
237 we have without erroring out or trying to get a default. */
238
239 void
240 set_default_source_symtab_and_line (void)
241 {
242 if (!have_full_symbols () && !have_partial_symbols ())
243 error (_("No symbol table is loaded. Use the \"file\" command."));
244
245 /* Pull in a current source symtab if necessary. */
246 current_source_location *loc = get_source_location (current_program_space);
247 if (loc->symtab () == nullptr)
248 select_source_symtab (0);
249 }
250
251 /* Return the current default file for listing and next line to list
252 (the returned sal pc and end fields are not valid.)
253 and set the current default to whatever is in SAL.
254 NOTE: The returned sal pc and end fields are not valid. */
255
256 struct symtab_and_line
257 set_current_source_symtab_and_line (const symtab_and_line &sal)
258 {
259 symtab_and_line cursal;
260
261 current_source_location *loc = get_source_location (sal.pspace);
262
263 cursal.pspace = sal.pspace;
264 cursal.symtab = loc->symtab ();
265 cursal.line = loc->line ();
266 cursal.pc = 0;
267 cursal.end = 0;
268
269 loc->set (sal.symtab, sal.line);
270
271 /* Force the next "list" to center around the current line. */
272 clear_lines_listed_range ();
273
274 return cursal;
275 }
276
277 /* Reset any information stored about a default file and line to print. */
278
279 void
280 clear_current_source_symtab_and_line (void)
281 {
282 current_source_location *loc = get_source_location (current_program_space);
283 loc->set (nullptr, 0);
284 }
285
286 /* See source.h. */
287
288 void
289 select_source_symtab (struct symtab *s)
290 {
291 if (s)
292 {
293 current_source_location *loc
294 = get_source_location (SYMTAB_PSPACE (s));
295 loc->set (s, 1);
296 return;
297 }
298
299 current_source_location *loc = get_source_location (current_program_space);
300 if (loc->symtab () != nullptr)
301 return;
302
303 /* Make the default place to list be the function `main'
304 if one exists. */
305 block_symbol bsym = lookup_symbol (main_name (), 0, VAR_DOMAIN, 0);
306 if (bsym.symbol != nullptr && SYMBOL_CLASS (bsym.symbol) == LOC_BLOCK)
307 {
308 symtab_and_line sal = find_function_start_sal (bsym.symbol, true);
309 if (sal.symtab == NULL)
310 /* We couldn't find the location of `main', possibly due to missing
311 line number info, fall back to line 1 in the corresponding file. */
312 loc->set (symbol_symtab (bsym.symbol), 1);
313 else
314 loc->set (sal.symtab, std::max (sal.line - (lines_to_list - 1), 1));
315 return;
316 }
317
318 /* Alright; find the last file in the symtab list (ignoring .h's
319 and namespace symtabs). */
320
321 struct symtab *new_symtab = nullptr;
322
323 for (objfile *ofp : current_program_space->objfiles ())
324 {
325 for (compunit_symtab *cu : ofp->compunits ())
326 {
327 for (symtab *symtab : compunit_filetabs (cu))
328 {
329 const char *name = symtab->filename;
330 int len = strlen (name);
331
332 if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
333 || strcmp (name, "<<C++-namespaces>>") == 0)))
334 new_symtab = symtab;
335 }
336 }
337 }
338
339 loc->set (new_symtab, 1);
340 if (new_symtab != nullptr)
341 return;
342
343 for (objfile *objfile : current_program_space->objfiles ())
344 {
345 s = objfile->find_last_source_symtab ();
346 if (s)
347 new_symtab = s;
348 }
349 if (new_symtab != nullptr)
350 {
351 loc->set (new_symtab,1);
352 return;
353 }
354
355 error (_("Can't find a default source file"));
356 }
357 \f
358 /* Handler for "set directories path-list" command.
359 "set dir mumble" doesn't prepend paths, it resets the entire
360 path list. The theory is that set(show(dir)) should be a no-op. */
361
362 static void
363 set_directories_command (const char *args,
364 int from_tty, struct cmd_list_element *c)
365 {
366 /* This is the value that was set.
367 It needs to be processed to maintain $cdir:$cwd and remove dups. */
368 char *set_path = source_path;
369
370 /* We preserve the invariant that $cdir:$cwd begins life at the end of
371 the list by calling init_source_path. If they appear earlier in
372 SET_PATH then mod_path will move them appropriately.
373 mod_path will also remove duplicates. */
374 init_source_path ();
375 if (*set_path != '\0')
376 mod_path (set_path, &source_path);
377
378 xfree (set_path);
379 }
380
381 /* Print the list of source directories.
382 This is used by the "ld" command, so it has the signature of a command
383 function. */
384
385 static void
386 show_directories_1 (char *ignore, int from_tty)
387 {
388 puts_filtered ("Source directories searched: ");
389 puts_filtered (source_path);
390 puts_filtered ("\n");
391 }
392
393 /* Handler for "show directories" command. */
394
395 static void
396 show_directories_command (struct ui_file *file, int from_tty,
397 struct cmd_list_element *c, const char *value)
398 {
399 show_directories_1 (NULL, from_tty);
400 }
401
402 /* See source.h. */
403
404 void
405 forget_cached_source_info_for_objfile (struct objfile *objfile)
406 {
407 for (compunit_symtab *cu : objfile->compunits ())
408 {
409 for (symtab *s : compunit_filetabs (cu))
410 {
411 if (s->fullname != NULL)
412 {
413 xfree (s->fullname);
414 s->fullname = NULL;
415 }
416 }
417 }
418
419 objfile->forget_cached_source_info ();
420 }
421
422 /* See source.h. */
423
424 void
425 forget_cached_source_info (void)
426 {
427 for (struct program_space *pspace : program_spaces)
428 for (objfile *objfile : pspace->objfiles ())
429 {
430 forget_cached_source_info_for_objfile (objfile);
431 }
432
433 g_source_cache.clear ();
434 last_source_visited = NULL;
435 }
436
437 void
438 init_source_path (void)
439 {
440 char buf[20];
441
442 xsnprintf (buf, sizeof (buf), "$cdir%c$cwd", DIRNAME_SEPARATOR);
443 source_path = xstrdup (buf);
444 forget_cached_source_info ();
445 }
446
447 /* Add zero or more directories to the front of the source path. */
448
449 static void
450 directory_command (const char *dirname, int from_tty)
451 {
452 bool value_changed = false;
453 dont_repeat ();
454 /* FIXME, this goes to "delete dir"... */
455 if (dirname == 0)
456 {
457 if (!from_tty || query (_("Reinitialize source path to empty? ")))
458 {
459 xfree (source_path);
460 init_source_path ();
461 value_changed = true;
462 }
463 }
464 else
465 {
466 mod_path (dirname, &source_path);
467 forget_cached_source_info ();
468 value_changed = true;
469 }
470 if (value_changed)
471 {
472 gdb::observers::command_param_changed.notify ("directories", source_path);
473 if (from_tty)
474 show_directories_1 ((char *) 0, from_tty);
475 }
476 }
477
478 /* Add a path given with the -d command line switch.
479 This will not be quoted so we must not treat spaces as separators. */
480
481 void
482 directory_switch (const char *dirname, int from_tty)
483 {
484 add_path (dirname, &source_path, 0);
485 }
486
487 /* Add zero or more directories to the front of an arbitrary path. */
488
489 void
490 mod_path (const char *dirname, char **which_path)
491 {
492 add_path (dirname, which_path, 1);
493 }
494
495 /* Workhorse of mod_path. Takes an extra argument to determine
496 if dirname should be parsed for separators that indicate multiple
497 directories. This allows for interfaces that pre-parse the dirname
498 and allow specification of traditional separator characters such
499 as space or tab. */
500
501 void
502 add_path (const char *dirname, char **which_path, int parse_separators)
503 {
504 char *old = *which_path;
505 int prefix = 0;
506 std::vector<gdb::unique_xmalloc_ptr<char>> dir_vec;
507
508 if (dirname == 0)
509 return;
510
511 if (parse_separators)
512 {
513 /* This will properly parse the space and tab separators
514 and any quotes that may exist. */
515 gdb_argv argv (dirname);
516
517 for (char *arg : argv)
518 dirnames_to_char_ptr_vec_append (&dir_vec, arg);
519 }
520 else
521 dir_vec.emplace_back (xstrdup (dirname));
522
523 for (const gdb::unique_xmalloc_ptr<char> &name_up : dir_vec)
524 {
525 char *name = name_up.get ();
526 char *p;
527 struct stat st;
528 gdb::unique_xmalloc_ptr<char> new_name_holder;
529
530 /* Spaces and tabs will have been removed by buildargv().
531 NAME is the start of the directory.
532 P is the '\0' following the end. */
533 p = name + strlen (name);
534
535 while (!(IS_DIR_SEPARATOR (*name) && p <= name + 1) /* "/" */
536 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
537 /* On MS-DOS and MS-Windows, h:\ is different from h: */
538 && !(p == name + 3 && name[1] == ':') /* "d:/" */
539 #endif
540 && p > name
541 && IS_DIR_SEPARATOR (p[-1]))
542 /* Sigh. "foo/" => "foo" */
543 --p;
544 *p = '\0';
545
546 while (p > name && p[-1] == '.')
547 {
548 if (p - name == 1)
549 {
550 /* "." => getwd (). */
551 name = current_directory;
552 goto append;
553 }
554 else if (p > name + 1 && IS_DIR_SEPARATOR (p[-2]))
555 {
556 if (p - name == 2)
557 {
558 /* "/." => "/". */
559 *--p = '\0';
560 goto append;
561 }
562 else
563 {
564 /* "...foo/." => "...foo". */
565 p -= 2;
566 *p = '\0';
567 continue;
568 }
569 }
570 else
571 break;
572 }
573
574 if (name[0] == '\0')
575 goto skip_dup;
576 if (name[0] == '~')
577 new_name_holder.reset (tilde_expand (name));
578 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
579 else if (IS_ABSOLUTE_PATH (name) && p == name + 2) /* "d:" => "d:." */
580 new_name_holder.reset (concat (name, ".", (char *) NULL));
581 #endif
582 else if (!IS_ABSOLUTE_PATH (name) && name[0] != '$')
583 new_name_holder = gdb_abspath (name);
584 else
585 new_name_holder.reset (savestring (name, p - name));
586 name = new_name_holder.get ();
587
588 /* Unless it's a variable, check existence. */
589 if (name[0] != '$')
590 {
591 /* These are warnings, not errors, since we don't want a
592 non-existent directory in a .gdbinit file to stop processing
593 of the .gdbinit file.
594
595 Whether they get added to the path is more debatable. Current
596 answer is yes, in case the user wants to go make the directory
597 or whatever. If the directory continues to not exist/not be
598 a directory/etc, then having them in the path should be
599 harmless. */
600 if (stat (name, &st) < 0)
601 {
602 int save_errno = errno;
603
604 fprintf_unfiltered (gdb_stderr, "Warning: ");
605 print_sys_errmsg (name, save_errno);
606 }
607 else if ((st.st_mode & S_IFMT) != S_IFDIR)
608 warning (_("%s is not a directory."), name);
609 }
610
611 append:
612 {
613 unsigned int len = strlen (name);
614 char tinybuf[2];
615
616 p = *which_path;
617 while (1)
618 {
619 /* FIXME: we should use realpath() or its work-alike
620 before comparing. Then all the code above which
621 removes excess slashes and dots could simply go away. */
622 if (!filename_ncmp (p, name, len)
623 && (p[len] == '\0' || p[len] == DIRNAME_SEPARATOR))
624 {
625 /* Found it in the search path, remove old copy. */
626 if (p > *which_path)
627 {
628 /* Back over leading separator. */
629 p--;
630 }
631 if (prefix > p - *which_path)
632 {
633 /* Same dir twice in one cmd. */
634 goto skip_dup;
635 }
636 /* Copy from next '\0' or ':'. */
637 memmove (p, &p[len + 1], strlen (&p[len + 1]) + 1);
638 }
639 p = strchr (p, DIRNAME_SEPARATOR);
640 if (p != 0)
641 ++p;
642 else
643 break;
644 }
645
646 tinybuf[0] = DIRNAME_SEPARATOR;
647 tinybuf[1] = '\0';
648
649 /* If we have already tacked on a name(s) in this command,
650 be sure they stay on the front as we tack on some
651 more. */
652 if (prefix)
653 {
654 char *temp, c;
655
656 c = old[prefix];
657 old[prefix] = '\0';
658 temp = concat (old, tinybuf, name, (char *)NULL);
659 old[prefix] = c;
660 *which_path = concat (temp, "", &old[prefix], (char *) NULL);
661 prefix = strlen (temp);
662 xfree (temp);
663 }
664 else
665 {
666 *which_path = concat (name, (old[0] ? tinybuf : old),
667 old, (char *)NULL);
668 prefix = strlen (name);
669 }
670 xfree (old);
671 old = *which_path;
672 }
673 skip_dup:
674 ;
675 }
676 }
677
678
679 static void
680 info_source_command (const char *ignore, int from_tty)
681 {
682 current_source_location *loc
683 = get_source_location (current_program_space);
684 struct symtab *s = loc->symtab ();
685 struct compunit_symtab *cust;
686
687 if (!s)
688 {
689 printf_filtered (_("No current source file.\n"));
690 return;
691 }
692
693 cust = SYMTAB_COMPUNIT (s);
694 printf_filtered (_("Current source file is %s\n"), s->filename);
695 if (SYMTAB_DIRNAME (s) != NULL)
696 printf_filtered (_("Compilation directory is %s\n"), SYMTAB_DIRNAME (s));
697 if (s->fullname)
698 printf_filtered (_("Located in %s\n"), s->fullname);
699 const std::vector<off_t> *offsets;
700 if (g_source_cache.get_line_charpos (s, &offsets))
701 printf_filtered (_("Contains %d line%s.\n"), (int) offsets->size (),
702 offsets->size () == 1 ? "" : "s");
703
704 printf_filtered (_("Source language is %s.\n"), language_str (s->language));
705 printf_filtered (_("Producer is %s.\n"),
706 COMPUNIT_PRODUCER (cust) != NULL
707 ? COMPUNIT_PRODUCER (cust) : _("unknown"));
708 printf_filtered (_("Compiled with %s debugging format.\n"),
709 COMPUNIT_DEBUGFORMAT (cust));
710 printf_filtered (_("%s preprocessor macro info.\n"),
711 COMPUNIT_MACRO_TABLE (cust) != NULL
712 ? "Includes" : "Does not include");
713 }
714 \f
715
716 /* Helper function to remove characters from the start of PATH so that
717 PATH can then be appended to a directory name. We remove leading drive
718 letters (for dos) as well as leading '/' characters and './'
719 sequences. */
720
721 static const char *
722 prepare_path_for_appending (const char *path)
723 {
724 /* For dos paths, d:/foo -> /foo, and d:foo -> foo. */
725 if (HAS_DRIVE_SPEC (path))
726 path = STRIP_DRIVE_SPEC (path);
727
728 const char *old_path;
729 do
730 {
731 old_path = path;
732
733 /* /foo => foo, to avoid multiple slashes that Emacs doesn't like. */
734 while (IS_DIR_SEPARATOR(path[0]))
735 path++;
736
737 /* ./foo => foo */
738 while (path[0] == '.' && IS_DIR_SEPARATOR (path[1]))
739 path += 2;
740 }
741 while (old_path != path);
742
743 return path;
744 }
745
746 /* Open a file named STRING, searching path PATH (dir names sep by some char)
747 using mode MODE in the calls to open. You cannot use this function to
748 create files (O_CREAT).
749
750 OPTS specifies the function behaviour in specific cases.
751
752 If OPF_TRY_CWD_FIRST, try to open ./STRING before searching PATH.
753 (ie pretend the first element of PATH is "."). This also indicates
754 that, unless OPF_SEARCH_IN_PATH is also specified, a slash in STRING
755 disables searching of the path (this is so that "exec-file ./foo" or
756 "symbol-file ./foo" insures that you get that particular version of
757 foo or an error message).
758
759 If OPTS has OPF_SEARCH_IN_PATH set, absolute names will also be
760 searched in path (we usually want this for source files but not for
761 executables).
762
763 If FILENAME_OPENED is non-null, set it to a newly allocated string naming
764 the actual file opened (this string will always start with a "/"). We
765 have to take special pains to avoid doubling the "/" between the directory
766 and the file, sigh! Emacs gets confuzzed by this when we print the
767 source file name!!!
768
769 If OPTS has OPF_RETURN_REALPATH set return FILENAME_OPENED resolved by
770 gdb_realpath. Even without OPF_RETURN_REALPATH this function still returns
771 filename starting with "/". If FILENAME_OPENED is NULL this option has no
772 effect.
773
774 If a file is found, return the descriptor.
775 Otherwise, return -1, with errno set for the last name we tried to open. */
776
777 /* >>>> This should only allow files of certain types,
778 >>>> eg executable, non-directory. */
779 int
780 openp (const char *path, openp_flags opts, const char *string,
781 int mode, gdb::unique_xmalloc_ptr<char> *filename_opened)
782 {
783 int fd;
784 char *filename;
785 int alloclen;
786 /* The errno set for the last name we tried to open (and
787 failed). */
788 int last_errno = 0;
789 std::vector<gdb::unique_xmalloc_ptr<char>> dir_vec;
790
791 /* The open syscall MODE parameter is not specified. */
792 gdb_assert ((mode & O_CREAT) == 0);
793 gdb_assert (string != NULL);
794
795 /* A file with an empty name cannot possibly exist. Report a failure
796 without further checking.
797
798 This is an optimization which also defends us against buggy
799 implementations of the "stat" function. For instance, we have
800 noticed that a MinGW debugger built on Windows XP 32bits crashes
801 when the debugger is started with an empty argument. */
802 if (string[0] == '\0')
803 {
804 errno = ENOENT;
805 return -1;
806 }
807
808 if (!path)
809 path = ".";
810
811 mode |= O_BINARY;
812
813 if ((opts & OPF_TRY_CWD_FIRST) || IS_ABSOLUTE_PATH (string))
814 {
815 int i, reg_file_errno;
816
817 if (is_regular_file (string, &reg_file_errno))
818 {
819 filename = (char *) alloca (strlen (string) + 1);
820 strcpy (filename, string);
821 fd = gdb_open_cloexec (filename, mode, 0);
822 if (fd >= 0)
823 goto done;
824 last_errno = errno;
825 }
826 else
827 {
828 filename = NULL;
829 fd = -1;
830 last_errno = reg_file_errno;
831 }
832
833 if (!(opts & OPF_SEARCH_IN_PATH))
834 for (i = 0; string[i]; i++)
835 if (IS_DIR_SEPARATOR (string[i]))
836 goto done;
837 }
838
839 /* Remove characters from the start of PATH that we don't need when PATH
840 is appended to a directory name. */
841 string = prepare_path_for_appending (string);
842
843 alloclen = strlen (path) + strlen (string) + 2;
844 filename = (char *) alloca (alloclen);
845 fd = -1;
846 last_errno = ENOENT;
847
848 dir_vec = dirnames_to_char_ptr_vec (path);
849
850 for (const gdb::unique_xmalloc_ptr<char> &dir_up : dir_vec)
851 {
852 char *dir = dir_up.get ();
853 size_t len = strlen (dir);
854 int reg_file_errno;
855
856 if (strcmp (dir, "$cwd") == 0)
857 {
858 /* Name is $cwd -- insert current directory name instead. */
859 int newlen;
860
861 /* First, realloc the filename buffer if too short. */
862 len = strlen (current_directory);
863 newlen = len + strlen (string) + 2;
864 if (newlen > alloclen)
865 {
866 alloclen = newlen;
867 filename = (char *) alloca (alloclen);
868 }
869 strcpy (filename, current_directory);
870 }
871 else if (strchr(dir, '~'))
872 {
873 /* See whether we need to expand the tilde. */
874 int newlen;
875
876 gdb::unique_xmalloc_ptr<char> tilde_expanded (tilde_expand (dir));
877
878 /* First, realloc the filename buffer if too short. */
879 len = strlen (tilde_expanded.get ());
880 newlen = len + strlen (string) + 2;
881 if (newlen > alloclen)
882 {
883 alloclen = newlen;
884 filename = (char *) alloca (alloclen);
885 }
886 strcpy (filename, tilde_expanded.get ());
887 }
888 else
889 {
890 /* Normal file name in path -- just use it. */
891 strcpy (filename, dir);
892
893 /* Don't search $cdir. It's also a magic path like $cwd, but we
894 don't have enough information to expand it. The user *could*
895 have an actual directory named '$cdir' but handling that would
896 be confusing, it would mean different things in different
897 contexts. If the user really has '$cdir' one can use './$cdir'.
898 We can get $cdir when loading scripts. When loading source files
899 $cdir must have already been expanded to the correct value. */
900 if (strcmp (dir, "$cdir") == 0)
901 continue;
902 }
903
904 /* Remove trailing slashes. */
905 while (len > 0 && IS_DIR_SEPARATOR (filename[len - 1]))
906 filename[--len] = 0;
907
908 strcat (filename + len, SLASH_STRING);
909 strcat (filename, string);
910
911 if (is_regular_file (filename, &reg_file_errno))
912 {
913 fd = gdb_open_cloexec (filename, mode, 0);
914 if (fd >= 0)
915 break;
916 last_errno = errno;
917 }
918 else
919 last_errno = reg_file_errno;
920 }
921
922 done:
923 if (filename_opened)
924 {
925 /* If a file was opened, canonicalize its filename. */
926 if (fd < 0)
927 filename_opened->reset (NULL);
928 else if ((opts & OPF_RETURN_REALPATH) != 0)
929 *filename_opened = gdb_realpath (filename);
930 else
931 *filename_opened = gdb_abspath (filename);
932 }
933
934 errno = last_errno;
935 return fd;
936 }
937
938
939 /* This is essentially a convenience, for clients that want the behaviour
940 of openp, using source_path, but that really don't want the file to be
941 opened but want instead just to know what the full pathname is (as
942 qualified against source_path).
943
944 The current working directory is searched first.
945
946 If the file was found, this function returns 1, and FULL_PATHNAME is
947 set to the fully-qualified pathname.
948
949 Else, this functions returns 0, and FULL_PATHNAME is set to NULL. */
950 int
951 source_full_path_of (const char *filename,
952 gdb::unique_xmalloc_ptr<char> *full_pathname)
953 {
954 int fd;
955
956 fd = openp (source_path,
957 OPF_TRY_CWD_FIRST | OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH,
958 filename, O_RDONLY, full_pathname);
959 if (fd < 0)
960 {
961 full_pathname->reset (NULL);
962 return 0;
963 }
964
965 close (fd);
966 return 1;
967 }
968
969 /* Return non-zero if RULE matches PATH, that is if the rule can be
970 applied to PATH. */
971
972 static int
973 substitute_path_rule_matches (const struct substitute_path_rule *rule,
974 const char *path)
975 {
976 const int from_len = strlen (rule->from);
977 const int path_len = strlen (path);
978
979 if (path_len < from_len)
980 return 0;
981
982 /* The substitution rules are anchored at the start of the path,
983 so the path should start with rule->from. */
984
985 if (filename_ncmp (path, rule->from, from_len) != 0)
986 return 0;
987
988 /* Make sure that the region in the path that matches the substitution
989 rule is immediately followed by a directory separator (or the end of
990 string character). */
991
992 if (path[from_len] != '\0' && !IS_DIR_SEPARATOR (path[from_len]))
993 return 0;
994
995 return 1;
996 }
997
998 /* Find the substitute-path rule that applies to PATH and return it.
999 Return NULL if no rule applies. */
1000
1001 static struct substitute_path_rule *
1002 get_substitute_path_rule (const char *path)
1003 {
1004 struct substitute_path_rule *rule = substitute_path_rules;
1005
1006 while (rule != NULL && !substitute_path_rule_matches (rule, path))
1007 rule = rule->next;
1008
1009 return rule;
1010 }
1011
1012 /* If the user specified a source path substitution rule that applies
1013 to PATH, then apply it and return the new path.
1014
1015 Return NULL if no substitution rule was specified by the user,
1016 or if no rule applied to the given PATH. */
1017
1018 gdb::unique_xmalloc_ptr<char>
1019 rewrite_source_path (const char *path)
1020 {
1021 const struct substitute_path_rule *rule = get_substitute_path_rule (path);
1022 char *new_path;
1023 int from_len;
1024
1025 if (rule == NULL)
1026 return NULL;
1027
1028 from_len = strlen (rule->from);
1029
1030 /* Compute the rewritten path and return it. */
1031
1032 new_path =
1033 (char *) xmalloc (strlen (path) + 1 + strlen (rule->to) - from_len);
1034 strcpy (new_path, rule->to);
1035 strcat (new_path, path + from_len);
1036
1037 return gdb::unique_xmalloc_ptr<char> (new_path);
1038 }
1039
1040 /* See source.h. */
1041
1042 scoped_fd
1043 find_and_open_source (const char *filename,
1044 const char *dirname,
1045 gdb::unique_xmalloc_ptr<char> *fullname)
1046 {
1047 char *path = source_path;
1048 const char *p;
1049 int result;
1050
1051 /* Quick way out if we already know its full name. */
1052
1053 if (*fullname)
1054 {
1055 /* The user may have requested that source paths be rewritten
1056 according to substitution rules he provided. If a substitution
1057 rule applies to this path, then apply it. */
1058 gdb::unique_xmalloc_ptr<char> rewritten_fullname
1059 = rewrite_source_path (fullname->get ());
1060
1061 if (rewritten_fullname != NULL)
1062 *fullname = std::move (rewritten_fullname);
1063
1064 result = gdb_open_cloexec (fullname->get (), OPEN_MODE, 0);
1065 if (result >= 0)
1066 {
1067 *fullname = gdb_realpath (fullname->get ());
1068 return scoped_fd (result);
1069 }
1070
1071 /* Didn't work -- free old one, try again. */
1072 fullname->reset (NULL);
1073 }
1074
1075 gdb::unique_xmalloc_ptr<char> rewritten_dirname;
1076 if (dirname != NULL)
1077 {
1078 /* If necessary, rewrite the compilation directory name according
1079 to the source path substitution rules specified by the user. */
1080
1081 rewritten_dirname = rewrite_source_path (dirname);
1082
1083 if (rewritten_dirname != NULL)
1084 dirname = rewritten_dirname.get ();
1085
1086 /* Replace a path entry of $cdir with the compilation directory
1087 name. */
1088 #define cdir_len 5
1089 p = strstr (source_path, "$cdir");
1090 if (p && (p == path || p[-1] == DIRNAME_SEPARATOR)
1091 && (p[cdir_len] == DIRNAME_SEPARATOR || p[cdir_len] == '\0'))
1092 {
1093 int len;
1094
1095 path = (char *)
1096 alloca (strlen (source_path) + 1 + strlen (dirname) + 1);
1097 len = p - source_path;
1098 strncpy (path, source_path, len); /* Before $cdir */
1099 strcpy (path + len, dirname); /* new stuff */
1100 strcat (path + len, source_path + len + cdir_len); /* After
1101 $cdir */
1102 }
1103 }
1104
1105 gdb::unique_xmalloc_ptr<char> rewritten_filename
1106 = rewrite_source_path (filename);
1107
1108 if (rewritten_filename != NULL)
1109 filename = rewritten_filename.get ();
1110
1111 /* Try to locate file using filename. */
1112 result = openp (path, OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH, filename,
1113 OPEN_MODE, fullname);
1114 if (result < 0 && dirname != NULL)
1115 {
1116 /* Remove characters from the start of PATH that we don't need when
1117 PATH is appended to a directory name. */
1118 const char *filename_start = prepare_path_for_appending (filename);
1119
1120 /* Try to locate file using compilation dir + filename. This is
1121 helpful if part of the compilation directory was removed,
1122 e.g. using gcc's -fdebug-prefix-map, and we have added the missing
1123 prefix to source_path. */
1124 std::string cdir_filename (dirname);
1125
1126 /* Remove any trailing directory separators. */
1127 while (IS_DIR_SEPARATOR (cdir_filename.back ()))
1128 cdir_filename.pop_back ();
1129
1130 /* Add our own directory separator. */
1131 cdir_filename.append (SLASH_STRING);
1132 cdir_filename.append (filename_start);
1133
1134 result = openp (path, OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH,
1135 cdir_filename.c_str (), OPEN_MODE, fullname);
1136 }
1137 if (result < 0)
1138 {
1139 /* Didn't work. Try using just the basename. */
1140 p = lbasename (filename);
1141 if (p != filename)
1142 result = openp (path, OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH, p,
1143 OPEN_MODE, fullname);
1144 }
1145
1146 return scoped_fd (result);
1147 }
1148
1149 /* Open a source file given a symtab S. Returns a file descriptor or
1150 negative number for error.
1151
1152 This function is a convenience function to find_and_open_source. */
1153
1154 scoped_fd
1155 open_source_file (struct symtab *s)
1156 {
1157 if (!s)
1158 return scoped_fd (-1);
1159
1160 gdb::unique_xmalloc_ptr<char> fullname (s->fullname);
1161 s->fullname = NULL;
1162 scoped_fd fd = find_and_open_source (s->filename, SYMTAB_DIRNAME (s),
1163 &fullname);
1164
1165 if (fd.get () < 0)
1166 {
1167 if (SYMTAB_COMPUNIT (s) != nullptr)
1168 {
1169 const objfile *ofp = COMPUNIT_OBJFILE (SYMTAB_COMPUNIT (s));
1170
1171 std::string srcpath;
1172 if (IS_ABSOLUTE_PATH (s->filename))
1173 srcpath = s->filename;
1174 else if (SYMTAB_DIRNAME (s) != nullptr)
1175 {
1176 srcpath = SYMTAB_DIRNAME (s);
1177 srcpath += SLASH_STRING;
1178 srcpath += s->filename;
1179 }
1180
1181 const struct bfd_build_id *build_id = build_id_bfd_get (ofp->obfd);
1182
1183 /* Query debuginfod for the source file. */
1184 if (build_id != nullptr && !srcpath.empty ())
1185 fd = debuginfod_source_query (build_id->data,
1186 build_id->size,
1187 srcpath.c_str (),
1188 &fullname);
1189 }
1190 }
1191
1192 s->fullname = fullname.release ();
1193 return fd;
1194 }
1195
1196 /* See source.h. */
1197
1198 gdb::unique_xmalloc_ptr<char>
1199 find_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
1233 const char *
1234 symtab_to_fullname (struct symtab *s)
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 (SYMTAB_DIRNAME (s) == NULL || IS_ABSOLUTE_PATH (s->filename))
1251 fullname.reset (xstrdup (s->filename));
1252 else
1253 fullname.reset (concat (SYMTAB_DIRNAME (s), SLASH_STRING,
1254 s->filename, (char *) NULL));
1255
1256 s->fullname = rewrite_source_path (fullname.get ()).release ();
1257 if (s->fullname == NULL)
1258 s->fullname = fullname.release ();
1259 }
1260 }
1261
1262 return s->fullname;
1263 }
1264
1265 /* See commentary in source.h. */
1266
1267 const char *
1268 symtab_to_filename_for_display (struct symtab *symtab)
1269 {
1270 if (filename_display_string == filename_display_basename)
1271 return lbasename (symtab->filename);
1272 else if (filename_display_string == filename_display_absolute)
1273 return symtab_to_fullname (symtab);
1274 else if (filename_display_string == filename_display_relative)
1275 return symtab->filename;
1276 else
1277 internal_error (__FILE__, __LINE__, _("invalid filename_display_string"));
1278 }
1279
1280 \f
1281
1282 /* Print source lines from the file of symtab S,
1283 starting with line number LINE and stopping before line number STOPLINE. */
1284
1285 static void
1286 print_source_lines_base (struct symtab *s, int line, int stopline,
1287 print_source_lines_flags flags)
1288 {
1289 bool noprint = false;
1290 int nlines = stopline - line;
1291 struct ui_out *uiout = current_uiout;
1292
1293 /* Regardless of whether we can open the file, set current_source_symtab. */
1294 current_source_location *loc
1295 = get_source_location (current_program_space);
1296
1297 loc->set (s, line);
1298 first_line_listed = line;
1299 last_line_listed = line;
1300
1301 /* If printing of source lines is disabled, just print file and line
1302 number. */
1303 if (uiout->test_flags (ui_source_list))
1304 {
1305 /* Only prints "No such file or directory" once. */
1306 if (s == last_source_visited)
1307 {
1308 if (last_source_error)
1309 {
1310 flags |= PRINT_SOURCE_LINES_NOERROR;
1311 noprint = true;
1312 }
1313 }
1314 else
1315 {
1316 last_source_visited = s;
1317 scoped_fd desc = open_source_file (s);
1318 last_source_error = desc.get () < 0;
1319 if (last_source_error)
1320 noprint = true;
1321 }
1322 }
1323 else
1324 {
1325 flags |= PRINT_SOURCE_LINES_NOERROR;
1326 noprint = true;
1327 }
1328
1329 if (noprint)
1330 {
1331 if (!(flags & PRINT_SOURCE_LINES_NOERROR))
1332 {
1333 const char *filename = symtab_to_filename_for_display (s);
1334 int len = strlen (filename) + 100;
1335 char *name = (char *) alloca (len);
1336
1337 xsnprintf (name, len, "%d\t%s", line, filename);
1338 print_sys_errmsg (name, errno);
1339 }
1340 else
1341 {
1342 uiout->field_signed ("line", line);
1343 uiout->text ("\tin ");
1344
1345 /* CLI expects only the "file" field. TUI expects only the
1346 "fullname" field (and TUI does break if "file" is printed).
1347 MI expects both fields. ui_source_list is set only for CLI,
1348 not for TUI. */
1349 if (uiout->is_mi_like_p () || uiout->test_flags (ui_source_list))
1350 uiout->field_string ("file", symtab_to_filename_for_display (s),
1351 file_name_style.style ());
1352 if (uiout->is_mi_like_p () || !uiout->test_flags (ui_source_list))
1353 {
1354 const char *s_fullname = symtab_to_fullname (s);
1355 char *local_fullname;
1356
1357 /* ui_out_field_string may free S_FULLNAME by calling
1358 open_source_file for it again. See e.g.,
1359 tui_field_string->tui_show_source. */
1360 local_fullname = (char *) alloca (strlen (s_fullname) + 1);
1361 strcpy (local_fullname, s_fullname);
1362
1363 uiout->field_string ("fullname", local_fullname);
1364 }
1365
1366 uiout->text ("\n");
1367 }
1368
1369 return;
1370 }
1371
1372 /* If the user requested a sequence of lines that seems to go backward
1373 (from high to low line numbers) then we don't print anything. */
1374 if (stopline <= line)
1375 return;
1376
1377 std::string lines;
1378 if (!g_source_cache.get_source_lines (s, line, stopline - 1, &lines))
1379 {
1380 const std::vector<off_t> *offsets = nullptr;
1381 g_source_cache.get_line_charpos (s, &offsets);
1382 error (_("Line number %d out of range; %s has %d lines."),
1383 line, symtab_to_filename_for_display (s),
1384 offsets == nullptr ? 0 : (int) offsets->size ());
1385 }
1386
1387 const char *iter = lines.c_str ();
1388 int new_lineno = loc->line ();
1389 while (nlines-- > 0 && *iter != '\0')
1390 {
1391 char buf[20];
1392
1393 last_line_listed = loc->line ();
1394 if (flags & PRINT_SOURCE_LINES_FILENAME)
1395 {
1396 uiout->text (symtab_to_filename_for_display (s));
1397 uiout->text (":");
1398 }
1399 xsnprintf (buf, sizeof (buf), "%d\t", new_lineno++);
1400 uiout->text (buf);
1401
1402 while (*iter != '\0')
1403 {
1404 /* Find a run of characters that can be emitted at once.
1405 This is done so that escape sequences are kept
1406 together. */
1407 const char *start = iter;
1408 while (true)
1409 {
1410 int skip_bytes;
1411
1412 char c = *iter;
1413 if (c == '\033' && skip_ansi_escape (iter, &skip_bytes))
1414 iter += skip_bytes;
1415 else if (c >= 0 && c < 040 && c != '\t')
1416 break;
1417 else if (c == 0177)
1418 break;
1419 else
1420 ++iter;
1421 }
1422 if (iter > start)
1423 {
1424 std::string text (start, iter);
1425 uiout->text (text);
1426 }
1427 if (*iter == '\r')
1428 {
1429 /* Treat either \r or \r\n as a single newline. */
1430 ++iter;
1431 if (*iter == '\n')
1432 ++iter;
1433 break;
1434 }
1435 else if (*iter == '\n')
1436 {
1437 ++iter;
1438 break;
1439 }
1440 else if (*iter > 0 && *iter < 040)
1441 {
1442 xsnprintf (buf, sizeof (buf), "^%c", *iter + 0100);
1443 uiout->text (buf);
1444 ++iter;
1445 }
1446 else if (*iter == 0177)
1447 {
1448 uiout->text ("^?");
1449 ++iter;
1450 }
1451 }
1452 uiout->text ("\n");
1453 }
1454
1455 loc->set (loc->symtab (), new_lineno);
1456 }
1457 \f
1458
1459 /* See source.h. */
1460
1461 void
1462 print_source_lines (struct symtab *s, int line, int stopline,
1463 print_source_lines_flags flags)
1464 {
1465 print_source_lines_base (s, line, stopline, flags);
1466 }
1467
1468 /* See source.h. */
1469
1470 void
1471 print_source_lines (struct symtab *s, source_lines_range line_range,
1472 print_source_lines_flags flags)
1473 {
1474 print_source_lines_base (s, line_range.startline (),
1475 line_range.stopline (), flags);
1476 }
1477
1478
1479 \f
1480 /* Print info on range of pc's in a specified line. */
1481
1482 static void
1483 info_line_command (const char *arg, int from_tty)
1484 {
1485 CORE_ADDR start_pc, end_pc;
1486
1487 std::vector<symtab_and_line> decoded_sals;
1488 symtab_and_line curr_sal;
1489 gdb::array_view<symtab_and_line> sals;
1490
1491 if (arg == 0)
1492 {
1493 current_source_location *loc
1494 = get_source_location (current_program_space);
1495 curr_sal.symtab = loc->symtab ();
1496 curr_sal.pspace = current_program_space;
1497 if (last_line_listed != 0)
1498 curr_sal.line = last_line_listed;
1499 else
1500 curr_sal.line = loc->line ();
1501
1502 sals = curr_sal;
1503 }
1504 else
1505 {
1506 decoded_sals = decode_line_with_last_displayed (arg,
1507 DECODE_LINE_LIST_MODE);
1508 sals = decoded_sals;
1509
1510 dont_repeat ();
1511 }
1512
1513 /* C++ More than one line may have been specified, as when the user
1514 specifies an overloaded function name. Print info on them all. */
1515 for (const auto &sal : sals)
1516 {
1517 if (sal.pspace != current_program_space)
1518 continue;
1519
1520 if (sal.symtab == 0)
1521 {
1522 struct gdbarch *gdbarch = get_current_arch ();
1523
1524 printf_filtered (_("No line number information available"));
1525 if (sal.pc != 0)
1526 {
1527 /* This is useful for "info line *0x7f34". If we can't tell the
1528 user about a source line, at least let them have the symbolic
1529 address. */
1530 printf_filtered (" for address ");
1531 wrap_here (" ");
1532 print_address (gdbarch, sal.pc, gdb_stdout);
1533 }
1534 else
1535 printf_filtered (".");
1536 printf_filtered ("\n");
1537 }
1538 else if (sal.line > 0
1539 && find_line_pc_range (sal, &start_pc, &end_pc))
1540 {
1541 struct gdbarch *gdbarch = SYMTAB_OBJFILE (sal.symtab)->arch ();
1542
1543 if (start_pc == end_pc)
1544 {
1545 printf_filtered ("Line %d of \"%s\"",
1546 sal.line,
1547 symtab_to_filename_for_display (sal.symtab));
1548 wrap_here (" ");
1549 printf_filtered (" is at address ");
1550 print_address (gdbarch, start_pc, gdb_stdout);
1551 wrap_here (" ");
1552 printf_filtered (" but contains no code.\n");
1553 }
1554 else
1555 {
1556 printf_filtered ("Line %d of \"%s\"",
1557 sal.line,
1558 symtab_to_filename_for_display (sal.symtab));
1559 wrap_here (" ");
1560 printf_filtered (" starts at address ");
1561 print_address (gdbarch, start_pc, gdb_stdout);
1562 wrap_here (" ");
1563 printf_filtered (" and ends at ");
1564 print_address (gdbarch, end_pc, gdb_stdout);
1565 printf_filtered (".\n");
1566 }
1567
1568 /* x/i should display this line's code. */
1569 set_next_address (gdbarch, start_pc);
1570
1571 /* Repeating "info line" should do the following line. */
1572 last_line_listed = sal.line + 1;
1573
1574 /* If this is the only line, show the source code. If it could
1575 not find the file, don't do anything special. */
1576 if (annotation_level > 0 && sals.size () == 1)
1577 annotate_source_line (sal.symtab, sal.line, 0, start_pc);
1578 }
1579 else
1580 /* Is there any case in which we get here, and have an address
1581 which the user would want to see? If we have debugging symbols
1582 and no line numbers? */
1583 printf_filtered (_("Line number %d is out of range for \"%s\".\n"),
1584 sal.line, symtab_to_filename_for_display (sal.symtab));
1585 }
1586 }
1587 \f
1588 /* Commands to search the source file for a regexp. */
1589
1590 /* Helper for forward_search_command/reverse_search_command. FORWARD
1591 indicates direction: true for forward, false for
1592 backward/reverse. */
1593
1594 static void
1595 search_command_helper (const char *regex, int from_tty, bool forward)
1596 {
1597 const char *msg = re_comp (regex);
1598 if (msg)
1599 error (("%s"), msg);
1600
1601 current_source_location *loc
1602 = get_source_location (current_program_space);
1603 if (loc->symtab () == nullptr)
1604 select_source_symtab (0);
1605
1606 scoped_fd desc (open_source_file (loc->symtab ()));
1607 if (desc.get () < 0)
1608 perror_with_name (symtab_to_filename_for_display (loc->symtab ()));
1609
1610 int line = (forward
1611 ? last_line_listed + 1
1612 : last_line_listed - 1);
1613
1614 const std::vector<off_t> *offsets;
1615 if (line < 1
1616 || !g_source_cache.get_line_charpos (loc->symtab (), &offsets)
1617 || line > offsets->size ())
1618 error (_("Expression not found"));
1619
1620 if (lseek (desc.get (), (*offsets)[line - 1], 0) < 0)
1621 perror_with_name (symtab_to_filename_for_display (loc->symtab ()));
1622
1623 gdb_file_up stream = desc.to_file (FDOPEN_MODE);
1624 clearerr (stream.get ());
1625
1626 gdb::def_vector<char> buf;
1627 buf.reserve (256);
1628
1629 while (1)
1630 {
1631 buf.resize (0);
1632
1633 int c = fgetc (stream.get ());
1634 if (c == EOF)
1635 break;
1636 do
1637 {
1638 buf.push_back (c);
1639 }
1640 while (c != '\n' && (c = fgetc (stream.get ())) >= 0);
1641
1642 /* Remove the \r, if any, at the end of the line, otherwise
1643 regular expressions that end with $ or \n won't work. */
1644 size_t sz = buf.size ();
1645 if (sz >= 2 && buf[sz - 2] == '\r')
1646 {
1647 buf[sz - 2] = '\n';
1648 buf.resize (sz - 1);
1649 }
1650
1651 /* We now have a source line in buf, null terminate and match. */
1652 buf.push_back ('\0');
1653 if (re_exec (buf.data ()) > 0)
1654 {
1655 /* Match! */
1656 print_source_lines (loc->symtab (), line, line + 1, 0);
1657 set_internalvar_integer (lookup_internalvar ("_"), line);
1658 loc->set (loc->symtab (), std::max (line - lines_to_list / 2, 1));
1659 return;
1660 }
1661
1662 if (forward)
1663 line++;
1664 else
1665 {
1666 line--;
1667 if (line < 1)
1668 break;
1669 if (fseek (stream.get (), (*offsets)[line - 1], 0) < 0)
1670 {
1671 const char *filename
1672 = symtab_to_filename_for_display (loc->symtab ());
1673 perror_with_name (filename);
1674 }
1675 }
1676 }
1677
1678 printf_filtered (_("Expression not found\n"));
1679 }
1680
1681 static void
1682 forward_search_command (const char *regex, int from_tty)
1683 {
1684 search_command_helper (regex, from_tty, true);
1685 }
1686
1687 static void
1688 reverse_search_command (const char *regex, int from_tty)
1689 {
1690 search_command_helper (regex, from_tty, false);
1691 }
1692
1693 /* If the last character of PATH is a directory separator, then strip it. */
1694
1695 static void
1696 strip_trailing_directory_separator (char *path)
1697 {
1698 const int last = strlen (path) - 1;
1699
1700 if (last < 0)
1701 return; /* No stripping is needed if PATH is the empty string. */
1702
1703 if (IS_DIR_SEPARATOR (path[last]))
1704 path[last] = '\0';
1705 }
1706
1707 /* Return the path substitution rule that matches FROM.
1708 Return NULL if no rule matches. */
1709
1710 static struct substitute_path_rule *
1711 find_substitute_path_rule (const char *from)
1712 {
1713 struct substitute_path_rule *rule = substitute_path_rules;
1714
1715 while (rule != NULL)
1716 {
1717 if (FILENAME_CMP (rule->from, from) == 0)
1718 return rule;
1719 rule = rule->next;
1720 }
1721
1722 return NULL;
1723 }
1724
1725 /* Add a new substitute-path rule at the end of the current list of rules.
1726 The new rule will replace FROM into TO. */
1727
1728 void
1729 add_substitute_path_rule (char *from, char *to)
1730 {
1731 struct substitute_path_rule *rule;
1732 struct substitute_path_rule *new_rule = XNEW (struct substitute_path_rule);
1733
1734 new_rule->from = xstrdup (from);
1735 new_rule->to = xstrdup (to);
1736 new_rule->next = NULL;
1737
1738 /* If the list of rules are empty, then insert the new rule
1739 at the head of the list. */
1740
1741 if (substitute_path_rules == NULL)
1742 {
1743 substitute_path_rules = new_rule;
1744 return;
1745 }
1746
1747 /* Otherwise, skip to the last rule in our list and then append
1748 the new rule. */
1749
1750 rule = substitute_path_rules;
1751 while (rule->next != NULL)
1752 rule = rule->next;
1753
1754 rule->next = new_rule;
1755 }
1756
1757 /* Remove the given source path substitution rule from the current list
1758 of rules. The memory allocated for that rule is also deallocated. */
1759
1760 static void
1761 delete_substitute_path_rule (struct substitute_path_rule *rule)
1762 {
1763 if (rule == substitute_path_rules)
1764 substitute_path_rules = rule->next;
1765 else
1766 {
1767 struct substitute_path_rule *prev = substitute_path_rules;
1768
1769 while (prev != NULL && prev->next != rule)
1770 prev = prev->next;
1771
1772 gdb_assert (prev != NULL);
1773
1774 prev->next = rule->next;
1775 }
1776
1777 xfree (rule->from);
1778 xfree (rule->to);
1779 xfree (rule);
1780 }
1781
1782 /* Implement the "show substitute-path" command. */
1783
1784 static void
1785 show_substitute_path_command (const char *args, int from_tty)
1786 {
1787 struct substitute_path_rule *rule = substitute_path_rules;
1788 char *from = NULL;
1789
1790 gdb_argv argv (args);
1791
1792 /* We expect zero or one argument. */
1793
1794 if (argv != NULL && argv[0] != NULL && argv[1] != NULL)
1795 error (_("Too many arguments in command"));
1796
1797 if (argv != NULL && argv[0] != NULL)
1798 from = argv[0];
1799
1800 /* Print the substitution rules. */
1801
1802 if (from != NULL)
1803 printf_filtered
1804 (_("Source path substitution rule matching `%s':\n"), from);
1805 else
1806 printf_filtered (_("List of all source path substitution rules:\n"));
1807
1808 while (rule != NULL)
1809 {
1810 if (from == NULL || substitute_path_rule_matches (rule, from) != 0)
1811 printf_filtered (" `%s' -> `%s'.\n", rule->from, rule->to);
1812 rule = rule->next;
1813 }
1814 }
1815
1816 /* Implement the "unset substitute-path" command. */
1817
1818 static void
1819 unset_substitute_path_command (const char *args, int from_tty)
1820 {
1821 struct substitute_path_rule *rule = substitute_path_rules;
1822 gdb_argv argv (args);
1823 char *from = NULL;
1824 int rule_found = 0;
1825
1826 /* This function takes either 0 or 1 argument. */
1827
1828 if (argv != NULL && argv[0] != NULL && argv[1] != NULL)
1829 error (_("Incorrect usage, too many arguments in command"));
1830
1831 if (argv != NULL && argv[0] != NULL)
1832 from = argv[0];
1833
1834 /* If the user asked for all the rules to be deleted, ask him
1835 to confirm and give him a chance to abort before the action
1836 is performed. */
1837
1838 if (from == NULL
1839 && !query (_("Delete all source path substitution rules? ")))
1840 error (_("Canceled"));
1841
1842 /* Delete the rule matching the argument. No argument means that
1843 all rules should be deleted. */
1844
1845 while (rule != NULL)
1846 {
1847 struct substitute_path_rule *next = rule->next;
1848
1849 if (from == NULL || FILENAME_CMP (from, rule->from) == 0)
1850 {
1851 delete_substitute_path_rule (rule);
1852 rule_found = 1;
1853 }
1854
1855 rule = next;
1856 }
1857
1858 /* If the user asked for a specific rule to be deleted but
1859 we could not find it, then report an error. */
1860
1861 if (from != NULL && !rule_found)
1862 error (_("No substitution rule defined for `%s'"), from);
1863
1864 forget_cached_source_info ();
1865 }
1866
1867 /* Add a new source path substitution rule. */
1868
1869 static void
1870 set_substitute_path_command (const char *args, int from_tty)
1871 {
1872 struct substitute_path_rule *rule;
1873
1874 gdb_argv argv (args);
1875
1876 if (argv == NULL || argv[0] == NULL || argv [1] == NULL)
1877 error (_("Incorrect usage, too few arguments in command"));
1878
1879 if (argv[2] != NULL)
1880 error (_("Incorrect usage, too many arguments in command"));
1881
1882 if (*(argv[0]) == '\0')
1883 error (_("First argument must be at least one character long"));
1884
1885 /* Strip any trailing directory separator character in either FROM
1886 or TO. The substitution rule already implicitly contains them. */
1887 strip_trailing_directory_separator (argv[0]);
1888 strip_trailing_directory_separator (argv[1]);
1889
1890 /* If a rule with the same "from" was previously defined, then
1891 delete it. This new rule replaces it. */
1892
1893 rule = find_substitute_path_rule (argv[0]);
1894 if (rule != NULL)
1895 delete_substitute_path_rule (rule);
1896
1897 /* Insert the new substitution rule. */
1898
1899 add_substitute_path_rule (argv[0], argv[1]);
1900 forget_cached_source_info ();
1901 }
1902
1903 /* See source.h. */
1904
1905 source_lines_range::source_lines_range (int startline,
1906 source_lines_range::direction dir)
1907 {
1908 if (dir == source_lines_range::FORWARD)
1909 {
1910 LONGEST end = static_cast <LONGEST> (startline) + get_lines_to_list ();
1911
1912 if (end > INT_MAX)
1913 end = INT_MAX;
1914
1915 m_startline = startline;
1916 m_stopline = static_cast <int> (end);
1917 }
1918 else
1919 {
1920 LONGEST start = static_cast <LONGEST> (startline) - get_lines_to_list ();
1921
1922 if (start < 1)
1923 start = 1;
1924
1925 m_startline = static_cast <int> (start);
1926 m_stopline = startline;
1927 }
1928 }
1929
1930 \f
1931 void _initialize_source ();
1932 void
1933 _initialize_source ()
1934 {
1935 init_source_path ();
1936
1937 /* The intention is to use POSIX Basic Regular Expressions.
1938 Always use the GNU regex routine for consistency across all hosts.
1939 Our current GNU regex.c does not have all the POSIX features, so this is
1940 just an approximation. */
1941 re_set_syntax (RE_SYNTAX_GREP);
1942
1943 cmd_list_element *directory_cmd
1944 = add_cmd ("directory", class_files, directory_command, _("\
1945 Add directory DIR to beginning of search path for source files.\n\
1946 Forget cached info on source file locations and line positions.\n\
1947 DIR can also be $cwd for the current working directory, or $cdir for the\n\
1948 directory in which the source file was compiled into object code.\n\
1949 With no argument, reset the search path to $cdir:$cwd, the default."),
1950 &cmdlist);
1951
1952 if (dbx_commands)
1953 add_com_alias ("use", directory_cmd, class_files, 0);
1954
1955 set_cmd_completer (directory_cmd, filename_completer);
1956
1957 add_setshow_optional_filename_cmd ("directories",
1958 class_files,
1959 &source_path,
1960 _("\
1961 Set the search path for finding source files."),
1962 _("\
1963 Show the search path for finding source files."),
1964 _("\
1965 $cwd in the path means the current working directory.\n\
1966 $cdir in the path means the compilation directory of the source file.\n\
1967 GDB ensures the search path always ends with $cdir:$cwd by\n\
1968 appending these directories if necessary.\n\
1969 Setting the value to an empty string sets it to $cdir:$cwd, the default."),
1970 set_directories_command,
1971 show_directories_command,
1972 &setlist, &showlist);
1973
1974 add_info ("source", info_source_command,
1975 _("Information about the current source file."));
1976
1977 add_info ("line", info_line_command, _("\
1978 Core addresses of the code for a source line.\n\
1979 Line can be specified as\n\
1980 LINENUM, to list around that line in current file,\n\
1981 FILE:LINENUM, to list around that line in that file,\n\
1982 FUNCTION, to list around beginning of that function,\n\
1983 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1984 Default is to describe the last source line that was listed.\n\n\
1985 This sets the default address for \"x\" to the line's first instruction\n\
1986 so that \"x/i\" suffices to start examining the machine code.\n\
1987 The address is also stored as the value of \"$_\"."));
1988
1989 cmd_list_element *forward_search_cmd
1990 = add_com ("forward-search", class_files, forward_search_command, _("\
1991 Search for regular expression (see regex(3)) from last line listed.\n\
1992 The matching line number is also stored as the value of \"$_\"."));
1993 add_com_alias ("search", forward_search_cmd, class_files, 0);
1994 add_com_alias ("fo", forward_search_cmd, class_files, 1);
1995
1996 cmd_list_element *reverse_search_cmd
1997 = add_com ("reverse-search", class_files, reverse_search_command, _("\
1998 Search backward for regular expression (see regex(3)) from last line listed.\n\
1999 The matching line number is also stored as the value of \"$_\"."));
2000 add_com_alias ("rev", reverse_search_cmd, class_files, 1);
2001
2002 add_setshow_integer_cmd ("listsize", class_support, &lines_to_list, _("\
2003 Set number of source lines gdb will list by default."), _("\
2004 Show number of source lines gdb will list by default."), _("\
2005 Use this to choose how many source lines the \"list\" displays (unless\n\
2006 the \"list\" argument explicitly specifies some other number).\n\
2007 A value of \"unlimited\", or zero, means there's no limit."),
2008 NULL,
2009 show_lines_to_list,
2010 &setlist, &showlist);
2011
2012 add_cmd ("substitute-path", class_files, set_substitute_path_command,
2013 _("\
2014 Add a substitution rule to rewrite the source directories.\n\
2015 Usage: set substitute-path FROM TO\n\
2016 The rule is applied only if the directory name starts with FROM\n\
2017 directly followed by a directory separator.\n\
2018 If a substitution rule was previously set for FROM, the old rule\n\
2019 is replaced by the new one."),
2020 &setlist);
2021
2022 add_cmd ("substitute-path", class_files, unset_substitute_path_command,
2023 _("\
2024 Delete one or all substitution rules rewriting the source directories.\n\
2025 Usage: unset substitute-path [FROM]\n\
2026 Delete the rule for substituting FROM in source directories. If FROM\n\
2027 is not specified, all substituting rules are deleted.\n\
2028 If the debugger cannot find a rule for FROM, it will display a warning."),
2029 &unsetlist);
2030
2031 add_cmd ("substitute-path", class_files, show_substitute_path_command,
2032 _("\
2033 Show one or all substitution rules rewriting the source directories.\n\
2034 Usage: show substitute-path [FROM]\n\
2035 Print the rule for substituting FROM in source directories. If FROM\n\
2036 is not specified, print all substitution rules."),
2037 &showlist);
2038
2039 add_setshow_enum_cmd ("filename-display", class_files,
2040 filename_display_kind_names,
2041 &filename_display_string, _("\
2042 Set how to display filenames."), _("\
2043 Show how to display filenames."), _("\
2044 filename-display can be:\n\
2045 basename - display only basename of a filename\n\
2046 relative - display a filename relative to the compilation directory\n\
2047 absolute - display an absolute filename\n\
2048 By default, relative filenames are displayed."),
2049 NULL,
2050 show_filename_display_string,
2051 &setlist, &showlist);
2052
2053 }