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