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