1/* List lines of source files for GDB, the GNU debugger. 2 Copyright (C) 1986-2023 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19#include "defs.h" 20#include "arch-utils.h" 21#include "symtab.h" 22#include "expression.h" 23#include "language.h" 24#include "command.h" 25#include "source.h" 26#include "gdbcmd.h" 27#include "frame.h" 28#include "value.h" 29#include "gdbsupport/filestuff.h" 30 31#include <sys/types.h> 32#include <fcntl.h> 33#include "gdbcore.h" 34#include "gdbsupport/gdb_regex.h" 35#include "symfile.h" 36#include "objfiles.h" 37#include "annotate.h" 38#include "gdbtypes.h" 39#include "linespec.h" 40#include "filenames.h" /* 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#include "gdbsupport/buildargv.h" 54 55#define OPEN_MODE (O_RDONLY | O_BINARY) 56#define FDOPEN_MODE FOPEN_RB 57 58/* Path of directories to search for source files. 59 Same format as the PATH environment variable's value. */ 60 61std::string source_path; 62 63/* Support for source path substitution commands. */ 64 65struct substitute_path_rule 66{ 67 substitute_path_rule (const char *from_, const char *to_) 68 : from (from_), 69 to (to_) 70 { 71 } 72 73 std::string from; 74 std::string to; 75}; 76 77static std::list<substitute_path_rule> substitute_path_rules; 78 79/* An instance of this is attached to each program space. */ 80 81struct current_source_location 82{ 83public: 84 85 current_source_location () = default; 86 87 /* Set the value. */ 88 void set (struct symtab *s, int l) 89 { 90 m_symtab = s; 91 m_line = l; 92 gdb::observers::current_source_symtab_and_line_changed.notify (); 93 } 94 95 /* Get the symtab. */ 96 struct symtab *symtab () const 97 { 98 return m_symtab; 99 } 100 101 /* Get the line number. */ 102 int line () const 103 { 104 return m_line; 105 } 106 107private: 108 109 /* Symtab of default file for listing lines of. */ 110 111 struct symtab *m_symtab = nullptr; 112 113 /* Default next line to list. */ 114 115 int m_line = 0; 116}; 117 118static const registry<program_space>::key<current_source_location> 119 current_source_key; 120 121/* Default number of lines to print with commands like "list". 122 This is based on guessing how many long (i.e. more than chars_per_line 123 characters) lines there will be. To be completely correct, "list" 124 and friends should be rewritten to count characters and see where 125 things are wrapping, but that would be a fair amount of work. */ 126 127static int lines_to_list = 10; 128static void 129show_lines_to_list (struct ui_file *file, int from_tty, 130 struct cmd_list_element *c, const char *value) 131{ 132 gdb_printf (file, 133 _("Number of source lines gdb " 134 "will list by default is %s.\n"), 135 value); 136} 137 138/* Possible values of 'set filename-display'. */ 139static const char filename_display_basename[] = "basename"; 140static const char filename_display_relative[] = "relative"; 141static const char filename_display_absolute[] = "absolute"; 142 143static const char *const filename_display_kind_names[] = { 144 filename_display_basename, 145 filename_display_relative, 146 filename_display_absolute, 147 NULL 148}; 149 150static const char *filename_display_string = filename_display_relative; 151 152static void 153show_filename_display_string (struct ui_file *file, int from_tty, 154 struct cmd_list_element *c, const char *value) 155{ 156 gdb_printf (file, _("Filenames are displayed as \"%s\".\n"), value); 157} 158 159/* When true GDB will stat and open source files as required, but when 160 false, GDB will avoid accessing source files as much as possible. */ 161 162static bool source_open = true; 163 164/* Implement 'show source open'. */ 165 166static void 167show_source_open (struct ui_file *file, int from_tty, 168 struct cmd_list_element *c, const char *value) 169{ 170 gdb_printf (file, _("Source opening is \"%s\".\n"), value); 171} 172 173/* Line number of last line printed. Default for various commands. 174 current_source_line is usually, but not always, the same as this. */ 175 176static int last_line_listed; 177 178/* First line number listed by last listing command. If 0, then no 179 source lines have yet been listed since the last time the current 180 source line was changed. */ 181 182static int first_line_listed; 183 184/* Saves the name of the last source file visited and a possible error code. 185 Used to prevent repeating annoying "No such file or directories" msgs. */ 186 187static struct symtab *last_source_visited = NULL; 188static bool last_source_error = false; 189 190/* Return the first line listed by print_source_lines. 191 Used by command interpreters to request listing from 192 a previous point. */ 193 194int 195get_first_line_listed (void) 196{ 197 return first_line_listed; 198} 199 200/* Clear line listed range. This makes the next "list" center the 201 printed source lines around the current source line. */ 202 203static void 204clear_lines_listed_range (void) 205{ 206 first_line_listed = 0; 207 last_line_listed = 0; 208} 209 210/* Return the default number of lines to print with commands like the 211 cli "list". The caller of print_source_lines must use this to 212 calculate the end line and use it in the call to print_source_lines 213 as it does not automatically use this value. */ 214 215int 216get_lines_to_list (void) 217{ 218 return lines_to_list; 219} 220 221/* A helper to return the current source location object for PSPACE, 222 creating it if it does not exist. */ 223 224static current_source_location * 225get_source_location (program_space *pspace) 226{ 227 current_source_location *loc 228 = current_source_key.get (pspace); 229 if (loc == nullptr) 230 loc = current_source_key.emplace (pspace); 231 return loc; 232} 233 234/* Return the current source file for listing and next line to list. 235 NOTE: The returned sal pc and end fields are not valid. */ 236 237struct symtab_and_line 238get_current_source_symtab_and_line (void) 239{ 240 symtab_and_line cursal; 241 current_source_location *loc = get_source_location (current_program_space); 242 243 cursal.pspace = current_program_space; 244 cursal.symtab = loc->symtab (); 245 cursal.line = loc->line (); 246 cursal.pc = 0; 247 cursal.end = 0; 248 249 return cursal; 250} 251 252/* If the current source file for listing is not set, try and get a default. 253 Usually called before get_current_source_symtab_and_line() is called. 254 It may err out if a default cannot be determined. 255 We must be cautious about where it is called, as it can recurse as the 256 process of determining a new default may call the caller! 257 Use get_current_source_symtab_and_line only to get whatever 258 we have without erroring out or trying to get a default. */ 259 260void 261set_default_source_symtab_and_line (void) 262{ 263 if (!have_full_symbols () && !have_partial_symbols ()) 264 error (_("No symbol table is loaded. Use the \"file\" command.")); 265 266 /* Pull in a current source symtab if necessary. */ 267 current_source_location *loc = get_source_location (current_program_space); 268 if (loc->symtab () == nullptr) 269 select_source_symtab (0); 270} 271 272/* Return the current default file for listing and next line to list 273 (the returned sal pc and end fields are not valid.) 274 and set the current default to whatever is in SAL. 275 NOTE: The returned sal pc and end fields are not valid. */ 276 277struct symtab_and_line 278set_current_source_symtab_and_line (const symtab_and_line &sal) 279{ 280 symtab_and_line cursal; 281 282 current_source_location *loc = get_source_location (sal.pspace); 283 284 cursal.pspace = sal.pspace; 285 cursal.symtab = loc->symtab (); 286 cursal.line = loc->line (); 287 cursal.pc = 0; 288 cursal.end = 0; 289 290 loc->set (sal.symtab, sal.line); 291 292 /* Force the next "list" to center around the current line. */ 293 clear_lines_listed_range (); 294 295 return cursal; 296} 297 298/* Reset any information stored about a default file and line to print. */ 299 300void 301clear_current_source_symtab_and_line (void) 302{ 303 current_source_location *loc = get_source_location (current_program_space); 304 loc->set (nullptr, 0); 305} 306 307/* See source.h. */ 308 309void 310select_source_symtab (struct symtab *s) 311{ 312 if (s) 313 { 314 current_source_location *loc 315 = get_source_location (s->compunit ()->objfile ()->pspace); 316 loc->set (s, 1); 317 return; 318 } 319 320 current_source_location *loc = get_source_location (current_program_space); 321 if (loc->symtab () != nullptr) 322 return; 323 324 /* Make the default place to list be the function `main' 325 if one exists. */ 326 block_symbol bsym = lookup_symbol (main_name (), 0, VAR_DOMAIN, 0); 327 if (bsym.symbol != nullptr && bsym.symbol->aclass () == LOC_BLOCK) 328 { 329 symtab_and_line sal = find_function_start_sal (bsym.symbol, true); 330 if (sal.symtab == NULL) 331 /* We couldn't find the location of `main', possibly due to missing 332 line number info, fall back to line 1 in the corresponding file. */ 333 loc->set (bsym.symbol->symtab (), 1); 334 else 335 loc->set (sal.symtab, std::max (sal.line - (lines_to_list - 1), 1)); 336 return; 337 } 338 339 /* Alright; find the last file in the symtab list (ignoring .h's 340 and namespace symtabs). */ 341 342 struct symtab *new_symtab = nullptr; 343 344 for (objfile *ofp : current_program_space->objfiles ()) 345 { 346 for (compunit_symtab *cu : ofp->compunits ()) 347 { 348 for (symtab *symtab : cu->filetabs ()) 349 { 350 const char *name = symtab->filename; 351 int len = strlen (name); 352 353 if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0 354 || strcmp (name, "<<C++-namespaces>>") == 0))) 355 new_symtab = symtab; 356 } 357 } 358 } 359 360 loc->set (new_symtab, 1); 361 if (new_symtab != nullptr) 362 return; 363 364 for (objfile *objfile : current_program_space->objfiles ()) 365 { 366 s = objfile->find_last_source_symtab (); 367 if (s) 368 new_symtab = s; 369 } 370 if (new_symtab != nullptr) 371 { 372 loc->set (new_symtab,1); 373 return; 374 } 375 376 error (_("Can't find a default source file")); 377} 378 379/* Handler for "set directories path-list" command. 380 "set dir mumble" doesn't prepend paths, it resets the entire 381 path list. The theory is that set(show(dir)) should be a no-op. */ 382 383static void 384set_directories_command (const char *args, 385 int from_tty, struct cmd_list_element *c) 386{ 387 /* This is the value that was set. 388 It needs to be processed to maintain $cdir:$cwd and remove dups. */ 389 std::string set_path = source_path; 390 391 /* We preserve the invariant that $cdir:$cwd begins life at the end of 392 the list by calling init_source_path. If they appear earlier in 393 SET_PATH then mod_path will move them appropriately. 394 mod_path will also remove duplicates. */ 395 init_source_path (); 396 if (!set_path.empty ()) 397 mod_path (set_path.c_str (), source_path); 398} 399 400/* Print the list of source directories. 401 This is used by the "ld" command, so it has the signature of a command 402 function. */ 403 404static void 405show_directories_1 (ui_file *file, char *ignore, int from_tty) 406{ 407 gdb_puts ("Source directories searched: ", file); 408 gdb_puts (source_path.c_str (), file); 409 gdb_puts ("\n", file); 410} 411 412/* Handler for "show directories" command. */ 413 414static void 415show_directories_command (struct ui_file *file, int from_tty, 416 struct cmd_list_element *c, const char *value) 417{ 418 show_directories_1 (file, NULL, from_tty); 419} 420 421/* See source.h. */ 422 423void 424forget_cached_source_info_for_objfile (struct objfile *objfile) 425{ 426 for (compunit_symtab *cu : objfile->compunits ()) 427 { 428 for (symtab *s : cu->filetabs ()) 429 { 430 if (s->fullname != NULL) 431 { 432 xfree (s->fullname); 433 s->fullname = NULL; 434 } 435 } 436 } 437 438 objfile->forget_cached_source_info (); 439} 440 441/* See source.h. */ 442 443void 444forget_cached_source_info (void) 445{ 446 for (struct program_space *pspace : program_spaces) 447 for (objfile *objfile : pspace->objfiles ()) 448 { 449 forget_cached_source_info_for_objfile (objfile); 450 } 451 452 g_source_cache.clear (); 453 last_source_visited = NULL; 454} 455 456void 457init_source_path (void) 458{ 459 source_path = string_printf ("$cdir%c$cwd", DIRNAME_SEPARATOR); 460 forget_cached_source_info (); 461} 462 463/* Add zero or more directories to the front of the source path. */ 464 465static void 466directory_command (const char *dirname, int from_tty) 467{ 468 bool value_changed = false; 469 dont_repeat (); 470 /* FIXME, this goes to "delete dir"... */ 471 if (dirname == 0) 472 { 473 if (!from_tty || query (_("Reinitialize source path to empty? "))) 474 { 475 init_source_path (); 476 value_changed = true; 477 } 478 } 479 else 480 { 481 mod_path (dirname, source_path); 482 forget_cached_source_info (); 483 value_changed = true; 484 } 485 if (value_changed) 486 { 487 gdb::observers::command_param_changed.notify ("directories", 488 source_path.c_str ()); 489 if (from_tty) 490 show_directories_1 (gdb_stdout, (char *) 0, from_tty); 491 } 492} 493 494/* Add a path given with the -d command line switch. 495 This will not be quoted so we must not treat spaces as separators. */ 496 497void 498directory_switch (const char *dirname, int from_tty) 499{ 500 add_path (dirname, source_path, 0); 501} 502 503/* Add zero or more directories to the front of an arbitrary path. */ 504 505void 506mod_path (const char *dirname, std::string &which_path) 507{ 508 add_path (dirname, which_path, 1); 509} 510 511/* Workhorse of mod_path. Takes an extra argument to determine 512 if dirname should be parsed for separators that indicate multiple 513 directories. This allows for interfaces that pre-parse the dirname 514 and allow specification of traditional separator characters such 515 as space or tab. */ 516 517void 518add_path (const char *dirname, char **which_path, int parse_separators) 519{ 520 char *old = *which_path; 521 int prefix = 0; 522 std::vector<gdb::unique_xmalloc_ptr<char>> dir_vec; 523 524 if (dirname == 0) 525 return; 526 527 if (parse_separators) 528 { 529 /* This will properly parse the space and tab separators 530 and any quotes that may exist. */ 531 gdb_argv argv (dirname); 532 533 for (char *arg : argv) 534 dirnames_to_char_ptr_vec_append (&dir_vec, arg); 535 } 536 else 537 dir_vec.emplace_back (xstrdup (dirname)); 538 539 for (const gdb::unique_xmalloc_ptr<char> &name_up : dir_vec) 540 { 541 const char *name = name_up.get (); 542 char *p; 543 struct stat st; 544 std::string new_name_holder; 545 546 /* Spaces and tabs will have been removed by buildargv(). 547 NAME is the start of the directory. 548 P is the '\0' following the end. */ 549 p = name_up.get () + strlen (name); 550 551 while (!(IS_DIR_SEPARATOR (*name) && p <= name + 1) /* "/" */ 552#ifdef HAVE_DOS_BASED_FILE_SYSTEM 553 /* On MS-DOS and MS-Windows, h:\ is different from h: */ 554 && !(p == name + 3 && name[1] == ':') /* "d:/" */ 555#endif 556 && p > name 557 && IS_DIR_SEPARATOR (p[-1])) 558 /* Sigh. "foo/" => "foo" */ 559 --p; 560 *p = '\0'; 561 562 while (p > name && p[-1] == '.') 563 { 564 if (p - name == 1) 565 { 566 /* "." => getwd (). */ 567 name = current_directory; 568 goto append; 569 } 570 else if (p > name + 1 && IS_DIR_SEPARATOR (p[-2])) 571 { 572 if (p - name == 2) 573 { 574 /* "/." => "/". */ 575 *--p = '\0'; 576 goto append; 577 } 578 else 579 { 580 /* "...foo/." => "...foo". */ 581 p -= 2; 582 *p = '\0'; 583 continue; 584 } 585 } 586 else 587 break; 588 } 589 590 if (name[0] == '\0') 591 goto skip_dup; 592 if (name[0] == '~') 593 new_name_holder 594 = gdb::unique_xmalloc_ptr<char[]> (tilde_expand (name)).get (); 595#ifdef HAVE_DOS_BASED_FILE_SYSTEM 596 else if (IS_ABSOLUTE_PATH (name) && p == name + 2) /* "d:" => "d:." */ 597 new_name_holder = std::string (name) + "."; 598#endif 599 else if (!IS_ABSOLUTE_PATH (name) && name[0] != '$') 600 new_name_holder = gdb_abspath (name); 601 else 602 new_name_holder = std::string (name, p - name); 603 604 name = new_name_holder.c_str (); 605 606 /* Unless it's a variable, check existence. */ 607 if (name[0] != '$') 608 { 609 /* These are warnings, not errors, since we don't want a 610 non-existent directory in a .gdbinit file to stop processing 611 of the .gdbinit file. 612 613 Whether they get added to the path is more debatable. Current 614 answer is yes, in case the user wants to go make the directory 615 or whatever. If the directory continues to not exist/not be 616 a directory/etc, then having them in the path should be 617 harmless. */ 618 if (stat (name, &st) < 0) 619 { 620 int save_errno = errno; 621 622 gdb_printf (gdb_stderr, "Warning: "); 623 print_sys_errmsg (name, save_errno); 624 } 625 else if ((st.st_mode & S_IFMT) != S_IFDIR) 626 warning (_("%s is not a directory."), name); 627 } 628 629 append: 630 { 631 unsigned int len = strlen (name); 632 char tinybuf[2]; 633 634 p = *which_path; 635 while (1) 636 { 637 /* FIXME: we should use realpath() or its work-alike 638 before comparing. Then all the code above which 639 removes excess slashes and dots could simply go away. */ 640 if (!filename_ncmp (p, name, len) 641 && (p[len] == '\0' || p[len] == DIRNAME_SEPARATOR)) 642 { 643 /* Found it in the search path, remove old copy. */ 644 if (p > *which_path) 645 { 646 /* Back over leading separator. */ 647 p--; 648 } 649 if (prefix > p - *which_path) 650 { 651 /* Same dir twice in one cmd. */ 652 goto skip_dup; 653 } 654 /* Copy from next '\0' or ':'. */ 655 memmove (p, &p[len + 1], strlen (&p[len + 1]) + 1); 656 } 657 p = strchr (p, DIRNAME_SEPARATOR); 658 if (p != 0) 659 ++p; 660 else 661 break; 662 } 663 664 tinybuf[0] = DIRNAME_SEPARATOR; 665 tinybuf[1] = '\0'; 666 667 /* If we have already tacked on a name(s) in this command, 668 be sure they stay on the front as we tack on some 669 more. */ 670 if (prefix) 671 { 672 std::string temp = std::string (old, prefix) + tinybuf + name; 673 *which_path = concat (temp.c_str (), &old[prefix], 674 (char *) nullptr); 675 prefix = temp.length (); 676 } 677 else 678 { 679 *which_path = concat (name, (old[0] ? tinybuf : old), 680 old, (char *)NULL); 681 prefix = strlen (name); 682 } 683 xfree (old); 684 old = *which_path; 685 } 686 skip_dup: 687 ; 688 } 689} 690 691/* add_path would need to be re-written to work on an std::string, but this is 692 not trivial. Hence this overload which copies to a `char *` and back. */ 693 694void 695add_path (const char *dirname, std::string &which_path, int parse_separators) 696{ 697 char *which_path_copy = xstrdup (which_path.data ()); 698 add_path (dirname, &which_path_copy, parse_separators); 699 which_path = which_path_copy; 700 xfree (which_path_copy); 701} 702 703static void 704info_source_command (const char *ignore, int from_tty) 705{ 706 current_source_location *loc 707 = get_source_location (current_program_space); 708 struct symtab *s = loc->symtab (); 709 struct compunit_symtab *cust; 710 711 if (!s) 712 { 713 gdb_printf (_("No current source file.\n")); 714 return; 715 } 716 717 cust = s->compunit (); 718 gdb_printf (_("Current source file is %s\n"), s->filename); 719 if (s->compunit ()->dirname () != NULL) 720 gdb_printf (_("Compilation directory is %s\n"), s->compunit ()->dirname ()); 721 if (s->fullname) 722 gdb_printf (_("Located in %s\n"), s->fullname); 723 const std::vector<off_t> *offsets; 724 if (g_source_cache.get_line_charpos (s, &offsets)) 725 gdb_printf (_("Contains %d line%s.\n"), (int) offsets->size (), 726 offsets->size () == 1 ? "" : "s"); 727 728 gdb_printf (_("Source language is %s.\n"), 729 language_str (s->language ())); 730 gdb_printf (_("Producer is %s.\n"), 731 (cust->producer ()) != nullptr 732 ? cust->producer () : _("unknown")); 733 gdb_printf (_("Compiled with %s debugging format.\n"), 734 cust->debugformat ()); 735 gdb_printf (_("%s preprocessor macro info.\n"), 736 (cust->macro_table () != nullptr 737 ? "Includes" : "Does not include")); 738} 739 740 741/* Helper function to remove characters from the start of PATH so that 742 PATH can then be appended to a directory name. We remove leading drive 743 letters (for dos) as well as leading '/' characters and './' 744 sequences. */ 745 746static const char * 747prepare_path_for_appending (const char *path) 748{ 749 /* For dos paths, d:/foo -> /foo, and d:foo -> foo. */ 750 if (HAS_DRIVE_SPEC (path)) 751 path = STRIP_DRIVE_SPEC (path); 752 753 const char *old_path; 754 do 755 { 756 old_path = path; 757 758 /* /foo => foo, to avoid multiple slashes that Emacs doesn't like. */ 759 while (IS_DIR_SEPARATOR(path[0])) 760 path++; 761 762 /* ./foo => foo */ 763 while (path[0] == '.' && IS_DIR_SEPARATOR (path[1])) 764 path += 2; 765 } 766 while (old_path != path); 767 768 return path; 769} 770 771/* Open a file named STRING, searching path PATH (dir names sep by some char) 772 using mode MODE in the calls to open. You cannot use this function to 773 create files (O_CREAT). 774 775 OPTS specifies the function behaviour in specific cases. 776 777 If OPF_TRY_CWD_FIRST, try to open ./STRING before searching PATH. 778 (ie pretend the first element of PATH is "."). This also indicates 779 that, unless OPF_SEARCH_IN_PATH is also specified, a slash in STRING 780 disables searching of the path (this is so that "exec-file ./foo" or 781 "symbol-file ./foo" insures that you get that particular version of 782 foo or an error message). 783 784 If OPTS has OPF_SEARCH_IN_PATH set, absolute names will also be 785 searched in path (we usually want this for source files but not for 786 executables). 787 788 If FILENAME_OPENED is non-null, set it to a newly allocated string naming 789 the actual file opened (this string will always start with a "/"). We 790 have to take special pains to avoid doubling the "/" between the directory 791 and the file, sigh! Emacs gets confuzzed by this when we print the 792 source file name!!! 793 794 If OPTS has OPF_RETURN_REALPATH set return FILENAME_OPENED resolved by 795 gdb_realpath. Even without OPF_RETURN_REALPATH this function still returns 796 filename starting with "/". If FILENAME_OPENED is NULL this option has no 797 effect. 798 799 If a file is found, return the descriptor. 800 Otherwise, return -1, with errno set for the last name we tried to open. */ 801 802/* >>>> This should only allow files of certain types, 803 >>>> eg executable, non-directory. */ 804int 805openp (const char *path, openp_flags opts, const char *string, 806 int mode, gdb::unique_xmalloc_ptr<char> *filename_opened) 807{ 808 int fd; 809 char *filename; 810 int alloclen; 811 /* The errno set for the last name we tried to open (and 812 failed). */ 813 int last_errno = 0; 814 std::vector<gdb::unique_xmalloc_ptr<char>> dir_vec; 815 816 /* The open syscall MODE parameter is not specified. */ 817 gdb_assert ((mode & O_CREAT) == 0); 818 gdb_assert (string != NULL); 819 820 /* A file with an empty name cannot possibly exist. Report a failure 821 without further checking. 822 823 This is an optimization which also defends us against buggy 824 implementations of the "stat" function. For instance, we have 825 noticed that a MinGW debugger built on Windows XP 32bits crashes 826 when the debugger is started with an empty argument. */ 827 if (string[0] == '\0') 828 { 829 errno = ENOENT; 830 return -1; 831 } 832 833 if (!path) 834 path = "."; 835 836 mode |= O_BINARY; 837 838 if ((opts & OPF_TRY_CWD_FIRST) || IS_ABSOLUTE_PATH (string)) 839 { 840 int i, reg_file_errno; 841 842 if (is_regular_file (string, ®_file_errno)) 843 { 844 filename = (char *) alloca (strlen (string) + 1); 845 strcpy (filename, string); 846 fd = gdb_open_cloexec (filename, mode, 0).release (); 847 if (fd >= 0) 848 goto done; 849 last_errno = errno; 850 } 851 else 852 { 853 filename = NULL; 854 fd = -1; 855 last_errno = reg_file_errno; 856 } 857 858 if (!(opts & OPF_SEARCH_IN_PATH)) 859 for (i = 0; string[i]; i++) 860 if (IS_DIR_SEPARATOR (string[i])) 861 goto done; 862 } 863 864 /* Remove characters from the start of PATH that we don't need when PATH 865 is appended to a directory name. */ 866 string = prepare_path_for_appending (string); 867 868 alloclen = strlen (path) + strlen (string) + 2; 869 filename = (char *) alloca (alloclen); 870 fd = -1; 871 last_errno = ENOENT; 872 873 dir_vec = dirnames_to_char_ptr_vec (path); 874 875 for (const gdb::unique_xmalloc_ptr<char> &dir_up : dir_vec) 876 { 877 char *dir = dir_up.get (); 878 size_t len = strlen (dir); 879 int reg_file_errno; 880 881 if (strcmp (dir, "$cwd") == 0) 882 { 883 /* Name is $cwd -- insert current directory name instead. */ 884 int newlen; 885 886 /* First, realloc the filename buffer if too short. */ 887 len = strlen (current_directory); 888 newlen = len + strlen (string) + 2; 889 if (newlen > alloclen) 890 { 891 alloclen = newlen; 892 filename = (char *) alloca (alloclen); 893 } 894 strcpy (filename, current_directory); 895 } 896 else if (strchr(dir, '~')) 897 { 898 /* See whether we need to expand the tilde. */ 899 int newlen; 900 901 gdb::unique_xmalloc_ptr<char> tilde_expanded (tilde_expand (dir)); 902 903 /* First, realloc the filename buffer if too short. */ 904 len = strlen (tilde_expanded.get ()); 905 newlen = len + strlen (string) + 2; 906 if (newlen > alloclen) 907 { 908 alloclen = newlen; 909 filename = (char *) alloca (alloclen); 910 } 911 strcpy (filename, tilde_expanded.get ()); 912 } 913 else 914 { 915 /* Normal file name in path -- just use it. */ 916 strcpy (filename, dir); 917 918 /* Don't search $cdir. It's also a magic path like $cwd, but we 919 don't have enough information to expand it. The user *could* 920 have an actual directory named '$cdir' but handling that would 921 be confusing, it would mean different things in different 922 contexts. If the user really has '$cdir' one can use './$cdir'. 923 We can get $cdir when loading scripts. When loading source files 924 $cdir must have already been expanded to the correct value. */ 925 if (strcmp (dir, "$cdir") == 0) 926 continue; 927 } 928 929 /* Remove trailing slashes. */ 930 while (len > 0 && IS_DIR_SEPARATOR (filename[len - 1])) 931 filename[--len] = 0; 932 933 strcat (filename + len, SLASH_STRING); 934 strcat (filename, string); 935 936 if (is_regular_file (filename, ®_file_errno)) 937 { 938 fd = gdb_open_cloexec (filename, mode, 0).release (); 939 if (fd >= 0) 940 break; 941 last_errno = errno; 942 } 943 else 944 last_errno = reg_file_errno; 945 } 946 947done: 948 if (filename_opened) 949 { 950 /* If a file was opened, canonicalize its filename. */ 951 if (fd < 0) 952 filename_opened->reset (NULL); 953 else if ((opts & OPF_RETURN_REALPATH) != 0) 954 *filename_opened = gdb_realpath (filename); 955 else 956 *filename_opened 957 = make_unique_xstrdup (gdb_abspath (filename).c_str ()); 958 } 959 960 errno = last_errno; 961 return fd; 962} 963 964 965/* This is essentially a convenience, for clients that want the behaviour 966 of openp, using source_path, but that really don't want the file to be 967 opened but want instead just to know what the full pathname is (as 968 qualified against source_path). 969 970 The current working directory is searched first. 971 972 If the file was found, this function returns 1, and FULL_PATHNAME is 973 set to the fully-qualified pathname. 974 975 Else, this functions returns 0, and FULL_PATHNAME is set to NULL. */ 976int 977source_full_path_of (const char *filename, 978 gdb::unique_xmalloc_ptr<char> *full_pathname) 979{ 980 int fd; 981 982 fd = openp (source_path.c_str (), 983 OPF_TRY_CWD_FIRST | OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH, 984 filename, O_RDONLY, full_pathname); 985 if (fd < 0) 986 { 987 full_pathname->reset (NULL); 988 return 0; 989 } 990 991 close (fd); 992 return 1; 993} 994 995/* Return non-zero if RULE matches PATH, that is if the rule can be 996 applied to PATH. */ 997 998static int 999substitute_path_rule_matches (const struct substitute_path_rule *rule, 1000 const char *path) 1001{ 1002 const int from_len = rule->from.length (); 1003 const int path_len = strlen (path); 1004 1005 if (path_len < from_len) 1006 return 0; 1007 1008 /* The substitution rules are anchored at the start of the path, 1009 so the path should start with rule->from. */ 1010 1011 if (filename_ncmp (path, rule->from.c_str (), from_len) != 0) 1012 return 0; 1013 1014 /* Make sure that the region in the path that matches the substitution 1015 rule is immediately followed by a directory separator (or the end of 1016 string character). */ 1017 1018 if (path[from_len] != '\0' && !IS_DIR_SEPARATOR (path[from_len])) 1019 return 0; 1020 1021 return 1; 1022} 1023 1024/* Find the substitute-path rule that applies to PATH and return it. 1025 Return NULL if no rule applies. */ 1026 1027static struct substitute_path_rule * 1028get_substitute_path_rule (const char *path) 1029{ 1030 for (substitute_path_rule &rule : substitute_path_rules) 1031 if (substitute_path_rule_matches (&rule, path)) 1032 return &rule; 1033 1034 return nullptr; 1035} 1036 1037/* If the user specified a source path substitution rule that applies 1038 to PATH, then apply it and return the new path. 1039 1040 Return NULL if no substitution rule was specified by the user, 1041 or if no rule applied to the given PATH. */ 1042 1043gdb::unique_xmalloc_ptr<char> 1044rewrite_source_path (const char *path) 1045{ 1046 const struct substitute_path_rule *rule = get_substitute_path_rule (path); 1047 1048 if (rule == nullptr) 1049 return nullptr; 1050 1051 /* Compute the rewritten path and return it. */ 1052 1053 return (gdb::unique_xmalloc_ptr<char> 1054 (concat (rule->to.c_str (), path + rule->from.length (), nullptr))); 1055} 1056 1057/* See source.h. */ 1058 1059scoped_fd 1060find_and_open_source (const char *filename, 1061 const char *dirname, 1062 gdb::unique_xmalloc_ptr<char> *fullname) 1063{ 1064 const char *path = source_path.c_str (); 1065 std::string expanded_path_holder; 1066 const char *p; 1067 1068 /* If reading of source files is disabled then return a result indicating 1069 the attempt to read this source file failed. GDB will then display 1070 the filename and line number instead. */ 1071 if (!source_open) 1072 return scoped_fd (-1); 1073 1074 /* Quick way out if we already know its full name. */ 1075 if (*fullname) 1076 { 1077 /* The user may have requested that source paths be rewritten 1078 according to substitution rules he provided. If a substitution 1079 rule applies to this path, then apply it. */ 1080 gdb::unique_xmalloc_ptr<char> rewritten_fullname 1081 = rewrite_source_path (fullname->get ()); 1082 1083 if (rewritten_fullname != NULL) 1084 *fullname = std::move (rewritten_fullname); 1085 1086 scoped_fd result = gdb_open_cloexec (fullname->get (), OPEN_MODE, 0); 1087 if (result.get () >= 0) 1088 { 1089 *fullname = gdb_realpath (fullname->get ()); 1090 return result; 1091 } 1092 1093 /* Didn't work -- free old one, try again. */ 1094 fullname->reset (NULL); 1095 } 1096 1097 gdb::unique_xmalloc_ptr<char> rewritten_dirname; 1098 if (dirname != NULL) 1099 { 1100 /* If necessary, rewrite the compilation directory name according 1101 to the source path substitution rules specified by the user. */ 1102 1103 rewritten_dirname = rewrite_source_path (dirname); 1104 1105 if (rewritten_dirname != NULL) 1106 dirname = rewritten_dirname.get (); 1107 1108 /* Replace a path entry of $cdir with the compilation directory 1109 name. */ 1110#define cdir_len 5 1111 p = strstr (source_path.c_str (), "$cdir"); 1112 if (p && (p == path || p[-1] == DIRNAME_SEPARATOR) 1113 && (p[cdir_len] == DIRNAME_SEPARATOR || p[cdir_len] == '\0')) 1114 { 1115 int len = p - source_path.c_str (); 1116 1117 /* Before $cdir */ 1118 expanded_path_holder = source_path.substr (0, len); 1119 1120 /* new stuff */ 1121 expanded_path_holder += dirname; 1122 1123 /* After $cdir */ 1124 expanded_path_holder += source_path.c_str () + len + cdir_len; 1125 1126 path = expanded_path_holder.c_str (); 1127 } 1128 } 1129 1130 gdb::unique_xmalloc_ptr<char> rewritten_filename 1131 = rewrite_source_path (filename); 1132 1133 if (rewritten_filename != NULL) 1134 filename = rewritten_filename.get (); 1135 1136 /* Try to locate file using filename. */ 1137 int result = openp (path, OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH, filename, 1138 OPEN_MODE, fullname); 1139 if (result < 0 && dirname != NULL) 1140 { 1141 /* Remove characters from the start of PATH that we don't need when 1142 PATH is appended to a directory name. */ 1143 const char *filename_start = prepare_path_for_appending (filename); 1144 1145 /* Try to locate file using compilation dir + filename. This is 1146 helpful if part of the compilation directory was removed, 1147 e.g. using gcc's -fdebug-prefix-map, and we have added the missing 1148 prefix to source_path. */ 1149 std::string cdir_filename = path_join (dirname, filename_start); 1150 1151 result = openp (path, OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH, 1152 cdir_filename.c_str (), OPEN_MODE, fullname); 1153 } 1154 if (result < 0) 1155 { 1156 /* Didn't work. Try using just the basename. */ 1157 p = lbasename (filename); 1158 if (p != filename) 1159 result = openp (path, OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH, p, 1160 OPEN_MODE, fullname); 1161 } 1162 1163 return scoped_fd (result); 1164} 1165 1166/* Open a source file given a symtab S. Returns a file descriptor or 1167 negative number for error. 1168 1169 This function is a convenience function to find_and_open_source. */ 1170 1171scoped_fd 1172open_source_file (struct symtab *s) 1173{ 1174 if (!s) 1175 return scoped_fd (-1); 1176 1177 gdb::unique_xmalloc_ptr<char> fullname (s->fullname); 1178 s->fullname = NULL; 1179 scoped_fd fd = find_and_open_source (s->filename, s->compunit ()->dirname (), 1180 &fullname); 1181 1182 if (fd.get () < 0) 1183 { 1184 if (s->compunit () != nullptr) 1185 { 1186 const objfile *ofp = s->compunit ()->objfile (); 1187 1188 std::string srcpath; 1189 if (IS_ABSOLUTE_PATH (s->filename)) 1190 srcpath = s->filename; 1191 else if (s->compunit ()->dirname () != nullptr) 1192 { 1193 srcpath = s->compunit ()->dirname (); 1194 srcpath += SLASH_STRING; 1195 srcpath += s->filename; 1196 } 1197 1198 const struct bfd_build_id *build_id 1199 = build_id_bfd_get (ofp->obfd.get ()); 1200 1201 /* Query debuginfod for the source file. */ 1202 if (build_id != nullptr && !srcpath.empty ()) 1203 fd = debuginfod_source_query (build_id->data, 1204 build_id->size, 1205 srcpath.c_str (), 1206 &fullname); 1207 } 1208 } 1209 1210 s->fullname = fullname.release (); 1211 return fd; 1212} 1213 1214/* See source.h. */ 1215 1216gdb::unique_xmalloc_ptr<char> 1217find_source_or_rewrite (const char *filename, const char *dirname) 1218{ 1219 gdb::unique_xmalloc_ptr<char> fullname; 1220 1221 scoped_fd fd = find_and_open_source (filename, dirname, &fullname); 1222 if (fd.get () < 0) 1223 { 1224 /* rewrite_source_path would be applied by find_and_open_source, we 1225 should report the pathname where GDB tried to find the file. */ 1226 1227 if (dirname == nullptr || IS_ABSOLUTE_PATH (filename)) 1228 fullname.reset (xstrdup (filename)); 1229 else 1230 fullname.reset (concat (dirname, SLASH_STRING, 1231 filename, (char *) nullptr)); 1232 1233 gdb::unique_xmalloc_ptr<char> rewritten 1234 = rewrite_source_path (fullname.get ()); 1235 if (rewritten != nullptr) 1236 fullname = std::move (rewritten); 1237 } 1238 1239 return fullname; 1240} 1241 1242/* Finds the fullname that a symtab represents. 1243 1244 This functions finds the fullname and saves it in s->fullname. 1245 It will also return the value. 1246 1247 If this function fails to find the file that this symtab represents, 1248 the expected fullname is used. Therefore the files does not have to 1249 exist. */ 1250 1251const char * 1252symtab_to_fullname (struct symtab *s) 1253{ 1254 /* Use cached copy if we have it. 1255 We rely on forget_cached_source_info being called appropriately 1256 to handle cases like the file being moved. */ 1257 if (s->fullname == NULL) 1258 { 1259 scoped_fd fd = open_source_file (s); 1260 1261 if (fd.get () < 0) 1262 { 1263 gdb::unique_xmalloc_ptr<char> fullname; 1264 1265 /* rewrite_source_path would be applied by find_and_open_source, we 1266 should report the pathname where GDB tried to find the file. */ 1267 1268 if (s->compunit ()->dirname () == nullptr 1269 || IS_ABSOLUTE_PATH (s->filename)) 1270 fullname.reset (xstrdup (s->filename)); 1271 else 1272 fullname.reset (concat (s->compunit ()->dirname (), 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 1286const char * 1287symtab_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 (_("invalid filename_display_string")); 1297} 1298 1299 1300 1301/* Print source lines from the file of symtab S, 1302 starting with line number LINE and stopping before line number STOPLINE. */ 1303 1304static void 1305print_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 1477 1478/* See source.h. */ 1479 1480void 1481print_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 1489void 1490print_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 1499/* Print info on range of pc's in a specified line. */ 1500 1501static void 1502info_line_command (const char *arg, int from_tty) 1503{ 1504 CORE_ADDR start_pc, end_pc; 1505 1506 std::vector<symtab_and_line> decoded_sals; 1507 symtab_and_line curr_sal; 1508 gdb::array_view<symtab_and_line> sals; 1509 1510 if (arg == 0) 1511 { 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 gdb_printf (_("No line number information available")); 1544 if (sal.pc != 0) 1545 { 1546 /* This is useful for "info line *0x7f34". If we can't tell the 1547 user about a source line, at least let them have the symbolic 1548 address. */ 1549 gdb_printf (" for address "); 1550 gdb_stdout->wrap_here (2); 1551 print_address (gdbarch, sal.pc, gdb_stdout); 1552 } 1553 else 1554 gdb_printf ("."); 1555 gdb_printf ("\n"); 1556 } 1557 else if (sal.line > 0 1558 && find_line_pc_range (sal, &start_pc, &end_pc)) 1559 { 1560 gdbarch *gdbarch = sal.symtab->compunit ()->objfile ()->arch (); 1561 1562 if (start_pc == end_pc) 1563 { 1564 gdb_printf ("Line %d of \"%s\"", 1565 sal.line, 1566 symtab_to_filename_for_display (sal.symtab)); 1567 gdb_stdout->wrap_here (2); 1568 gdb_printf (" is at address "); 1569 print_address (gdbarch, start_pc, gdb_stdout); 1570 gdb_stdout->wrap_here (2); 1571 gdb_printf (" but contains no code.\n"); 1572 } 1573 else 1574 { 1575 gdb_printf ("Line %d of \"%s\"", 1576 sal.line, 1577 symtab_to_filename_for_display (sal.symtab)); 1578 gdb_stdout->wrap_here (2); 1579 gdb_printf (" starts at address "); 1580 print_address (gdbarch, start_pc, gdb_stdout); 1581 gdb_stdout->wrap_here (2); 1582 gdb_printf (" and ends at "); 1583 print_address (gdbarch, end_pc, gdb_stdout); 1584 gdb_printf (".\n"); 1585 } 1586 1587 /* x/i should display this line's code. */ 1588 set_next_address (gdbarch, start_pc); 1589 1590 /* Repeating "info line" should do the following line. */ 1591 last_line_listed = sal.line + 1; 1592 1593 /* If this is the only line, show the source code. If it could 1594 not find the file, don't do anything special. */ 1595 if (annotation_level > 0 && sals.size () == 1) 1596 annotate_source_line (sal.symtab, sal.line, 0, start_pc); 1597 } 1598 else 1599 /* Is there any case in which we get here, and have an address 1600 which the user would want to see? If we have debugging symbols 1601 and no line numbers? */ 1602 gdb_printf (_("Line number %d is out of range for \"%s\".\n"), 1603 sal.line, symtab_to_filename_for_display (sal.symtab)); 1604 } 1605} 1606 1607/* Commands to search the source file for a regexp. */ 1608 1609/* Helper for forward_search_command/reverse_search_command. FORWARD 1610 indicates direction: true for forward, false for 1611 backward/reverse. */ 1612 1613static void 1614search_command_helper (const char *regex, int from_tty, bool forward) 1615{ 1616 const char *msg = re_comp (regex); 1617 if (msg) 1618 error (("%s"), msg); 1619 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 gdb_printf (_("Expression not found\n")); 1701} 1702 1703static void 1704forward_search_command (const char *regex, int from_tty) 1705{ 1706 search_command_helper (regex, from_tty, true); 1707} 1708 1709static void 1710reverse_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 1717static void 1718strip_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 1732void 1733add_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 1740static void 1741show_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 gdb_printf 1759 (_("Source path substitution rule matching `%s':\n"), from); 1760 else 1761 gdb_printf (_("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 gdb_printf (" `%s' -> `%s'.\n", rule.from.c_str (), 1767 rule.to.c_str ()); 1768 } 1769} 1770 1771/* Implement the "unset substitute-path" command. */ 1772 1773static void 1774unset_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 1825static void 1826set_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 1864source_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 1891static void 1892set_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 1899static void 1900show_source (const char *args, int from_tty) 1901{ 1902 help_list (showsourcelist, "show source ", all_commands, gdb_stdout); 1903} 1904 1905 1906void _initialize_source (); 1907void 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, _("\ 1920Add directory DIR to beginning of search path for source files.\n\ 1921Forget cached info on source file locations and line positions.\n\ 1922DIR can also be $cwd for the current working directory, or $cdir for the\n\ 1923directory in which the source file was compiled into object code.\n\ 1924With no argument, reset the search path to $cdir:$cwd, the default."), 1925 &cmdlist); 1926 1927 set_cmd_completer (directory_cmd, filename_completer); 1928 1929 add_setshow_optional_filename_cmd ("directories", 1930 class_files, 1931 &source_path, 1932 _("\ 1933Set the search path for finding source files."), 1934 _("\ 1935Show the search path for finding source files."), 1936 _("\ 1937$cwd in the path means the current working directory.\n\ 1938$cdir in the path means the compilation directory of the source file.\n\ 1939GDB ensures the search path always ends with $cdir:$cwd by\n\ 1940appending these directories if necessary.\n\ 1941Setting the value to an empty string sets it to $cdir:$cwd, the default."), 1942 set_directories_command, 1943 show_directories_command, 1944 &setlist, &showlist); 1945 1946 add_info ("source", info_source_command, 1947 _("Information about the current source file.")); 1948 1949 add_info ("line", info_line_command, _("\ 1950Core addresses of the code for a source line.\n\ 1951Line can be specified as\n\ 1952 LINENUM, to list around that line in current file,\n\ 1953 FILE:LINENUM, to list around that line in that file,\n\ 1954 FUNCTION, to list around beginning of that function,\n\ 1955 FILE:FUNCTION, to distinguish among like-named static functions.\n\ 1956Default is to describe the last source line that was listed.\n\n\ 1957This sets the default address for \"x\" to the line's first instruction\n\ 1958so that \"x/i\" suffices to start examining the machine code.\n\ 1959The address is also stored as the value of \"$_\".")); 1960 1961 cmd_list_element *forward_search_cmd 1962 = add_com ("forward-search", class_files, forward_search_command, _("\ 1963Search for regular expression (see regex(3)) from last line listed.\n\ 1964The matching line number is also stored as the value of \"$_\".")); 1965 add_com_alias ("search", forward_search_cmd, class_files, 0); 1966 add_com_alias ("fo", forward_search_cmd, class_files, 1); 1967 1968 cmd_list_element *reverse_search_cmd 1969 = add_com ("reverse-search", class_files, reverse_search_command, _("\ 1970Search backward for regular expression (see regex(3)) from last line listed.\n\ 1971The matching line number is also stored as the value of \"$_\".")); 1972 add_com_alias ("rev", reverse_search_cmd, class_files, 1); 1973 1974 add_setshow_integer_cmd ("listsize", class_support, &lines_to_list, _("\ 1975Set number of source lines gdb will list by default."), _("\ 1976Show number of source lines gdb will list by default."), _("\ 1977Use this to choose how many source lines the \"list\" displays (unless\n\ 1978the \"list\" argument explicitly specifies some other number).\n\ 1979A value of \"unlimited\", or zero, means there's no limit."), 1980 NULL, 1981 show_lines_to_list, 1982 &setlist, &showlist); 1983 1984 add_cmd ("substitute-path", class_files, set_substitute_path_command, 1985 _("\ 1986Add a substitution rule to rewrite the source directories.\n\ 1987Usage: set substitute-path FROM TO\n\ 1988The rule is applied only if the directory name starts with FROM\n\ 1989directly followed by a directory separator.\n\ 1990If a substitution rule was previously set for FROM, the old rule\n\ 1991is replaced by the new one."), 1992 &setlist); 1993 1994 add_cmd ("substitute-path", class_files, unset_substitute_path_command, 1995 _("\ 1996Delete one or all substitution rules rewriting the source directories.\n\ 1997Usage: unset substitute-path [FROM]\n\ 1998Delete the rule for substituting FROM in source directories. If FROM\n\ 1999is not specified, all substituting rules are deleted.\n\ 2000If the debugger cannot find a rule for FROM, it will display a warning."), 2001 &unsetlist); 2002 2003 add_cmd ("substitute-path", class_files, show_substitute_path_command, 2004 _("\ 2005Show one or all substitution rules rewriting the source directories.\n\ 2006Usage: show substitute-path [FROM]\n\ 2007Print the rule for substituting FROM in source directories. If FROM\n\ 2008is not specified, print all substitution rules."), 2009 &showlist); 2010 2011 add_setshow_enum_cmd ("filename-display", class_files, 2012 filename_display_kind_names, 2013 &filename_display_string, _("\ 2014Set how to display filenames."), _("\ 2015Show how to display filenames."), _("\ 2016filename-display can be:\n\ 2017 basename - display only basename of a filename\n\ 2018 relative - display a filename relative to the compilation directory\n\ 2019 absolute - display an absolute filename\n\ 2020By default, relative filenames are displayed."), 2021 NULL, 2022 show_filename_display_string, 2023 &setlist, &showlist); 2024 2025 add_prefix_cmd ("source", no_class, set_source, 2026 _("Generic command for setting how sources are handled."), 2027 &setsourcelist, 0, &setlist); 2028 2029 add_prefix_cmd ("source", no_class, show_source, 2030 _("Generic command for showing source settings."), 2031 &showsourcelist, 0, &showlist); 2032 2033 add_setshow_boolean_cmd ("open", class_files, &source_open, _("\ 2034Set whether GDB should open source files."), _("\ 2035Show whether GDB should open source files."), _("\ 2036When this option is on GDB will open source files and display the\n\ 2037contents when appropriate, for example, when GDB stops, or the list\n\ 2038command is used.\n\ 2039When this option is off GDB will not try to open source files, instead\n\ 2040GDB will print the file and line number that would have been displayed.\n\ 2041This can be useful if access to source code files is slow, for example\n\ 2042due to the source being located over a slow network connection."), 2043 NULL, 2044 show_source_open, 2045 &setsourcelist, &showsourcelist); 2046} 2047