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