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