1 /* Top level stuff for GDB, the GNU debugger. 2 3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 5 2009, 2010 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "top.h" 24 #include "target.h" 25 #include "inferior.h" 26 #include "symfile.h" 27 #include "gdbcore.h" 28 29 #include "exceptions.h" 30 #include "getopt.h" 31 32 #include <sys/types.h> 33 #include "gdb_stat.h" 34 #include <ctype.h> 35 36 #include "gdb_string.h" 37 #include "event-loop.h" 38 #include "ui-out.h" 39 40 #include "interps.h" 41 #include "main.h" 42 #include "source.h" 43 #include "cli/cli-cmds.h" 44 #include "python/python.h" 45 46 /* The selected interpreter. This will be used as a set command 47 variable, so it should always be malloc'ed - since 48 do_setshow_command will free it. */ 49 char *interpreter_p; 50 51 /* Whether xdb commands will be handled */ 52 int xdb_commands = 0; 53 54 /* Whether dbx commands will be handled */ 55 int dbx_commands = 0; 56 57 /* System root path, used to find libraries etc. */ 58 char *gdb_sysroot = 0; 59 60 /* GDB datadir, used to store data files. */ 61 char *gdb_datadir = 0; 62 63 /* If gdb was configured with --with-python=/path, 64 the possibly relocated path to python's lib directory. */ 65 char *python_libdir = 0; 66 67 struct ui_file *gdb_stdout; 68 struct ui_file *gdb_stderr; 69 struct ui_file *gdb_stdlog; 70 struct ui_file *gdb_stdin; 71 /* target IO streams */ 72 struct ui_file *gdb_stdtargin; 73 struct ui_file *gdb_stdtarg; 74 struct ui_file *gdb_stdtargerr; 75 76 /* True if --batch or --batch-silent was seen. */ 77 int batch_flag = 0; 78 79 /* Support for the --batch-silent option. */ 80 int batch_silent = 0; 81 82 /* Support for --return-child-result option. 83 Set the default to -1 to return error in the case 84 that the program does not run or does not complete. */ 85 int return_child_result = 0; 86 int return_child_result_value = -1; 87 88 /* Whether to enable writing into executable and core files */ 89 extern int write_files; 90 91 /* GDB as it has been invoked from the command line (i.e. argv[0]). */ 92 static char *gdb_program_name; 93 94 /* DragonFly kgdb support */ 95 int kernel_debugger; 96 97 static void print_gdb_help (struct ui_file *); 98 99 /* These two are used to set the external editor commands when gdb is farming 100 out files to be edited by another program. */ 101 102 extern char *external_editor_command; 103 104 /* Relocate a file or directory. PROGNAME is the name by which gdb 105 was invoked (i.e., argv[0]). INITIAL is the default value for the 106 file or directory. FLAG is true if the value is relocatable, false 107 otherwise. Returns a newly allocated string; this may return NULL 108 under the same conditions as make_relative_prefix. */ 109 static char * 110 relocate_path (const char *progname, const char *initial, int flag) 111 { 112 if (flag) 113 return make_relative_prefix (progname, BINDIR, initial); 114 return xstrdup (initial); 115 } 116 117 /* Like relocate_path, but specifically checks for a directory. 118 INITIAL is relocated according to the rules of relocate_path. If 119 the result is a directory, it is used; otherwise, INITIAL is used. 120 The chosen directory is then canonicalized using lrealpath. This 121 function always returns a newly-allocated string. */ 122 static char * 123 relocate_directory (const char *progname, const char *initial, int flag) 124 { 125 char *dir; 126 127 dir = relocate_path (progname, initial, flag); 128 if (dir) 129 { 130 struct stat s; 131 132 if (stat (dir, &s) != 0 || !S_ISDIR (s.st_mode)) 133 { 134 xfree (dir); 135 dir = NULL; 136 } 137 } 138 if (!dir) 139 dir = xstrdup (initial); 140 141 /* Canonicalize the directory. */ 142 if (*dir) 143 { 144 char *canon_sysroot = lrealpath (dir); 145 146 if (canon_sysroot) 147 { 148 xfree (dir); 149 dir = canon_sysroot; 150 } 151 } 152 153 return dir; 154 } 155 156 /* Compute the locations of init files that GDB should source and return 157 them in SYSTEM_GDBINIT, HOME_GDBINIT, LOCAL_GDBINIT. If there is 158 no system gdbinit (resp. home gdbinit and local gdbinit) to be loaded, 159 then SYSTEM_GDBINIT (resp. HOME_GDBINIT and LOCAL_GDBINIT) is set to 160 NULL. */ 161 static void 162 get_init_files (char **system_gdbinit, 163 char **home_gdbinit, 164 char **local_gdbinit) 165 { 166 static char *sysgdbinit = NULL; 167 static char *homeinit = NULL; 168 static char *localinit = NULL; 169 static int initialized = 0; 170 171 if (!initialized) 172 { 173 struct stat homebuf, cwdbuf, s; 174 char *homedir, *relocated_sysgdbinit; 175 176 if (SYSTEM_GDBINIT[0]) 177 { 178 relocated_sysgdbinit = relocate_path (gdb_program_name, 179 SYSTEM_GDBINIT, 180 SYSTEM_GDBINIT_RELOCATABLE); 181 if (relocated_sysgdbinit && stat (relocated_sysgdbinit, &s) == 0) 182 sysgdbinit = relocated_sysgdbinit; 183 else 184 xfree (relocated_sysgdbinit); 185 } 186 187 homedir = getenv ("HOME"); 188 189 /* If the .gdbinit file in the current directory is the same as 190 the $HOME/.gdbinit file, it should not be sourced. homebuf 191 and cwdbuf are used in that purpose. Make sure that the stats 192 are zero in case one of them fails (this guarantees that they 193 won't match if either exists). */ 194 195 memset (&homebuf, 0, sizeof (struct stat)); 196 memset (&cwdbuf, 0, sizeof (struct stat)); 197 198 if (homedir) 199 { 200 homeinit = xstrprintf ("%s/%s", homedir, gdbinit); 201 if (stat (homeinit, &homebuf) != 0) 202 { 203 xfree (homeinit); 204 homeinit = NULL; 205 } 206 } 207 208 if (stat (gdbinit, &cwdbuf) == 0) 209 { 210 if (!homeinit 211 || memcmp ((char *) &homebuf, (char *) &cwdbuf, 212 sizeof (struct stat))) 213 localinit = gdbinit; 214 } 215 216 initialized = 1; 217 } 218 219 *system_gdbinit = sysgdbinit; 220 *home_gdbinit = homeinit; 221 *local_gdbinit = localinit; 222 } 223 224 /* Call command_loop. If it happens to return, pass that through as a 225 non-zero return status. */ 226 227 static int 228 captured_command_loop (void *data) 229 { 230 current_interp_command_loop (); 231 /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton 232 would clean things up (restoring the cleanup chain) to the state 233 they were just prior to the call. Technically, this means that 234 the do_cleanups() below is redundant. Unfortunately, many FUNCs 235 are not that well behaved. do_cleanups should either be replaced 236 with a do_cleanups call (to cover the problem) or an assertion 237 check to detect bad FUNCs code. */ 238 do_cleanups (ALL_CLEANUPS); 239 /* If the command_loop returned, normally (rather than threw an 240 error) we try to quit. If the quit is aborted, catch_errors() 241 which called this catch the signal and restart the command 242 loop. */ 243 quit_command (NULL, instream == stdin); 244 return 1; 245 } 246 247 static int 248 captured_main (void *data) 249 { 250 struct captured_main_args *context = data; 251 int argc = context->argc; 252 char **argv = context->argv; 253 static int quiet = 0; 254 static int set_args = 0; 255 256 /* Pointers to various arguments from command line. */ 257 char *symarg = NULL; 258 char *execarg = NULL; 259 char *pidarg = NULL; 260 char *corearg = NULL; 261 char *pid_or_core_arg = NULL; 262 char *cdarg = NULL; 263 char *ttyarg = NULL; 264 265 /* These are static so that we can take their address in an initializer. */ 266 static int print_help; 267 static int print_version; 268 269 /* Pointers to all arguments of --command option. */ 270 struct cmdarg { 271 enum { 272 CMDARG_FILE, 273 CMDARG_COMMAND 274 } type; 275 char *string; 276 } *cmdarg; 277 /* Allocated size of cmdarg. */ 278 int cmdsize; 279 /* Number of elements of cmdarg used. */ 280 int ncmd; 281 282 /* Indices of all arguments of --directory option. */ 283 char **dirarg; 284 /* Allocated size. */ 285 int dirsize; 286 /* Number of elements used. */ 287 int ndir; 288 289 /* gdb init files. */ 290 char *system_gdbinit; 291 char *home_gdbinit; 292 char *local_gdbinit; 293 294 int i; 295 int save_auto_load; 296 297 struct cleanup *pre_stat_chain = make_command_stats_cleanup (0); 298 299 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) 300 setlocale (LC_MESSAGES, ""); 301 #endif 302 #if defined (HAVE_SETLOCALE) 303 setlocale (LC_CTYPE, ""); 304 #endif 305 bindtextdomain (PACKAGE, LOCALEDIR); 306 textdomain (PACKAGE); 307 308 #ifdef HAVE_SBRK 309 lim_at_start = (char *) sbrk (0); 310 #endif 311 312 cmdsize = 1; 313 cmdarg = (struct cmdarg *) xmalloc (cmdsize * sizeof (*cmdarg)); 314 ncmd = 0; 315 dirsize = 1; 316 dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg)); 317 ndir = 0; 318 319 quit_flag = 0; 320 line = (char *) xmalloc (linesize); 321 line[0] = '\0'; /* Terminate saved (now empty) cmd line */ 322 instream = stdin; 323 324 gdb_stdout = stdio_fileopen (stdout); 325 gdb_stderr = stdio_fileopen (stderr); 326 gdb_stdlog = gdb_stderr; /* for moment */ 327 gdb_stdtarg = gdb_stderr; /* for moment */ 328 gdb_stdin = stdio_fileopen (stdin); 329 gdb_stdtargerr = gdb_stderr; /* for moment */ 330 gdb_stdtargin = gdb_stdin; /* for moment */ 331 332 gdb_program_name = xstrdup (argv[0]); 333 334 if (! getcwd (gdb_dirbuf, sizeof (gdb_dirbuf))) 335 /* Don't use *_filtered or warning() (which relies on 336 current_target) until after initialize_all_files(). */ 337 fprintf_unfiltered (gdb_stderr, 338 _("%s: warning: error finding working directory: %s\n"), 339 argv[0], safe_strerror (errno)); 340 341 current_directory = gdb_dirbuf; 342 343 /* Set the sysroot path. */ 344 gdb_sysroot = relocate_directory (argv[0], TARGET_SYSTEM_ROOT, 345 TARGET_SYSTEM_ROOT_RELOCATABLE); 346 347 debug_file_directory = relocate_directory (argv[0], DEBUGDIR, 348 DEBUGDIR_RELOCATABLE); 349 350 gdb_datadir = relocate_directory (argv[0], GDB_DATADIR, 351 GDB_DATADIR_RELOCATABLE); 352 353 #ifdef WITH_PYTHON_PATH 354 /* For later use in helping Python find itself. */ 355 python_libdir = relocate_directory (argv[0], 356 concat (WITH_PYTHON_PATH, 357 SLASH_STRING, "lib", NULL), 358 PYTHON_PATH_RELOCATABLE); 359 #endif 360 361 #ifdef RELOC_SRCDIR 362 add_substitute_path_rule (RELOC_SRCDIR, 363 make_relative_prefix (argv[0], BINDIR, 364 RELOC_SRCDIR)); 365 #endif 366 367 /* There will always be an interpreter. Either the one passed into 368 this captured main, or one specified by the user at start up, or 369 the console. Initialize the interpreter to the one requested by 370 the application. */ 371 interpreter_p = xstrdup (context->interpreter_p); 372 373 /* Parse arguments and options. */ 374 { 375 int c; 376 /* When var field is 0, use flag field to record the equivalent 377 short option (or arbitrary numbers starting at 10 for those 378 with no equivalent). */ 379 enum { 380 OPT_SE = 10, 381 OPT_CD, 382 OPT_ANNOTATE, 383 OPT_STATISTICS, 384 OPT_TUI, 385 OPT_KGDB, 386 OPT_NOWINDOWS, 387 OPT_WINDOWS 388 }; 389 static struct option long_options[] = 390 { 391 {"tui", no_argument, 0, OPT_TUI}, 392 {"xdb", no_argument, &xdb_commands, 1}, 393 {"dbx", no_argument, &dbx_commands, 1}, 394 {"readnow", no_argument, &readnow_symbol_files, 1}, 395 {"r", no_argument, &readnow_symbol_files, 1}, 396 {"quiet", no_argument, &quiet, 1}, 397 {"q", no_argument, &quiet, 1}, 398 {"silent", no_argument, &quiet, 1}, 399 {"nx", no_argument, &inhibit_gdbinit, 1}, 400 {"n", no_argument, &inhibit_gdbinit, 1}, 401 {"batch-silent", no_argument, 0, 'B'}, 402 {"batch", no_argument, &batch_flag, 1}, 403 {"epoch", no_argument, &epoch_interface, 1}, 404 405 /* This is a synonym for "--annotate=1". --annotate is now preferred, 406 but keep this here for a long time because people will be running 407 emacses which use --fullname. */ 408 {"fullname", no_argument, 0, 'f'}, 409 {"f", no_argument, 0, 'f'}, 410 411 {"kernel", no_argument, 0, OPT_KGDB}, 412 {"annotate", required_argument, 0, OPT_ANNOTATE}, 413 {"help", no_argument, &print_help, 1}, 414 {"se", required_argument, 0, OPT_SE}, 415 {"symbols", required_argument, 0, 's'}, 416 {"s", required_argument, 0, 's'}, 417 {"exec", required_argument, 0, 'e'}, 418 {"e", required_argument, 0, 'e'}, 419 {"core", required_argument, 0, 'c'}, 420 {"c", required_argument, 0, 'c'}, 421 {"pid", required_argument, 0, 'p'}, 422 {"p", required_argument, 0, 'p'}, 423 {"command", required_argument, 0, 'x'}, 424 {"eval-command", required_argument, 0, 'X'}, 425 {"version", no_argument, &print_version, 1}, 426 {"x", required_argument, 0, 'x'}, 427 {"ex", required_argument, 0, 'X'}, 428 #ifdef GDBTK 429 {"tclcommand", required_argument, 0, 'z'}, 430 {"enable-external-editor", no_argument, 0, 'y'}, 431 {"editor-command", required_argument, 0, 'w'}, 432 #endif 433 {"ui", required_argument, 0, 'i'}, 434 {"interpreter", required_argument, 0, 'i'}, 435 {"i", required_argument, 0, 'i'}, 436 {"directory", required_argument, 0, 'd'}, 437 {"d", required_argument, 0, 'd'}, 438 {"cd", required_argument, 0, OPT_CD}, 439 {"tty", required_argument, 0, 't'}, 440 {"baud", required_argument, 0, 'b'}, 441 {"b", required_argument, 0, 'b'}, 442 {"nw", no_argument, NULL, OPT_NOWINDOWS}, 443 {"nowindows", no_argument, NULL, OPT_NOWINDOWS}, 444 {"w", no_argument, NULL, OPT_WINDOWS}, 445 {"windows", no_argument, NULL, OPT_WINDOWS}, 446 {"statistics", no_argument, 0, OPT_STATISTICS}, 447 {"write", no_argument, &write_files, 1}, 448 {"args", no_argument, &set_args, 1}, 449 {"l", required_argument, 0, 'l'}, 450 {"return-child-result", no_argument, &return_child_result, 1}, 451 {0, no_argument, 0, 0} 452 }; 453 454 while (1) 455 { 456 int option_index; 457 458 c = getopt_long_only (argc, argv, "", 459 long_options, &option_index); 460 if (c == EOF || set_args) 461 break; 462 463 /* Long option that takes an argument. */ 464 if (c == 0 && long_options[option_index].flag == 0) 465 c = long_options[option_index].val; 466 467 switch (c) 468 { 469 case 0: 470 /* Long option that just sets a flag. */ 471 break; 472 case OPT_SE: 473 symarg = optarg; 474 execarg = optarg; 475 break; 476 case OPT_CD: 477 cdarg = optarg; 478 break; 479 case OPT_ANNOTATE: 480 /* FIXME: what if the syntax is wrong (e.g. not digits)? */ 481 annotation_level = atoi (optarg); 482 break; 483 case OPT_STATISTICS: 484 /* Enable the display of both time and space usage. */ 485 set_display_time (1); 486 set_display_space (1); 487 break; 488 case OPT_TUI: 489 /* --tui is equivalent to -i=tui. */ 490 #ifdef TUI 491 xfree (interpreter_p); 492 interpreter_p = xstrdup (INTERP_TUI); 493 #else 494 fprintf_unfiltered (gdb_stderr, 495 _("%s: TUI mode is not supported\n"), 496 argv[0]); 497 exit (1); 498 #endif 499 break; 500 case OPT_KGDB: 501 kernel_debugger = 1; 502 break; 503 case OPT_WINDOWS: 504 /* FIXME: cagney/2003-03-01: Not sure if this option is 505 actually useful, and if it is, what it should do. */ 506 #ifdef GDBTK 507 /* --windows is equivalent to -i=insight. */ 508 xfree (interpreter_p); 509 interpreter_p = xstrdup (INTERP_INSIGHT); 510 #endif 511 use_windows = 1; 512 break; 513 case OPT_NOWINDOWS: 514 /* -nw is equivalent to -i=console. */ 515 xfree (interpreter_p); 516 interpreter_p = xstrdup (INTERP_CONSOLE); 517 use_windows = 0; 518 break; 519 case 'f': 520 annotation_level = 1; 521 /* We have probably been invoked from emacs. Disable window interface. */ 522 use_windows = 0; 523 break; 524 case 's': 525 symarg = optarg; 526 break; 527 case 'e': 528 execarg = optarg; 529 break; 530 case 'c': 531 corearg = optarg; 532 break; 533 case 'p': 534 pidarg = optarg; 535 break; 536 case 'x': 537 cmdarg[ncmd].type = CMDARG_FILE; 538 cmdarg[ncmd++].string = optarg; 539 if (ncmd >= cmdsize) 540 { 541 cmdsize *= 2; 542 cmdarg = xrealloc ((char *) cmdarg, 543 cmdsize * sizeof (*cmdarg)); 544 } 545 break; 546 case 'X': 547 cmdarg[ncmd].type = CMDARG_COMMAND; 548 cmdarg[ncmd++].string = optarg; 549 if (ncmd >= cmdsize) 550 { 551 cmdsize *= 2; 552 cmdarg = xrealloc ((char *) cmdarg, 553 cmdsize * sizeof (*cmdarg)); 554 } 555 break; 556 case 'B': 557 batch_flag = batch_silent = 1; 558 gdb_stdout = ui_file_new(); 559 break; 560 #ifdef GDBTK 561 case 'z': 562 { 563 extern int gdbtk_test (char *); 564 if (!gdbtk_test (optarg)) 565 { 566 fprintf_unfiltered (gdb_stderr, _("%s: unable to load tclcommand file \"%s\""), 567 argv[0], optarg); 568 exit (1); 569 } 570 break; 571 } 572 case 'y': 573 /* Backwards compatibility only. */ 574 break; 575 case 'w': 576 { 577 external_editor_command = xstrdup (optarg); 578 break; 579 } 580 #endif /* GDBTK */ 581 case 'i': 582 xfree (interpreter_p); 583 interpreter_p = xstrdup (optarg); 584 break; 585 case 'd': 586 dirarg[ndir++] = optarg; 587 if (ndir >= dirsize) 588 { 589 dirsize *= 2; 590 dirarg = (char **) xrealloc ((char *) dirarg, 591 dirsize * sizeof (*dirarg)); 592 } 593 break; 594 case 't': 595 ttyarg = optarg; 596 break; 597 case 'q': 598 quiet = 1; 599 break; 600 case 'b': 601 { 602 int i; 603 char *p; 604 605 i = strtol (optarg, &p, 0); 606 if (i == 0 && p == optarg) 607 608 /* Don't use *_filtered or warning() (which relies on 609 current_target) until after initialize_all_files(). */ 610 611 fprintf_unfiltered 612 (gdb_stderr, 613 _("warning: could not set baud rate to `%s'.\n"), optarg); 614 else 615 baud_rate = i; 616 } 617 break; 618 case 'l': 619 { 620 int i; 621 char *p; 622 623 i = strtol (optarg, &p, 0); 624 if (i == 0 && p == optarg) 625 626 /* Don't use *_filtered or warning() (which relies on 627 current_target) until after initialize_all_files(). */ 628 629 fprintf_unfiltered 630 (gdb_stderr, 631 _("warning: could not set timeout limit to `%s'.\n"), optarg); 632 else 633 remote_timeout = i; 634 } 635 break; 636 637 case '?': 638 fprintf_unfiltered (gdb_stderr, 639 _("Use `%s --help' for a complete list of options.\n"), 640 argv[0]); 641 exit (1); 642 } 643 } 644 645 /* If --help or --version, disable window interface. */ 646 if (print_help || print_version) 647 { 648 use_windows = 0; 649 } 650 651 if (batch_flag) 652 quiet = 1; 653 } 654 655 /* Initialize all files. Give the interpreter a chance to take 656 control of the console via the deprecated_init_ui_hook (). */ 657 gdb_init (argv[0]); 658 659 /* Now that gdb_init has created the initial inferior, we're in position 660 to set args for that inferior. */ 661 if (set_args) 662 { 663 /* The remaining options are the command-line options for the 664 inferior. The first one is the sym/exec file, and the rest 665 are arguments. */ 666 if (optind >= argc) 667 { 668 fprintf_unfiltered (gdb_stderr, 669 _("%s: `--args' specified but no program specified\n"), 670 argv[0]); 671 exit (1); 672 } 673 symarg = argv[optind]; 674 execarg = argv[optind]; 675 ++optind; 676 set_inferior_args_vector (argc - optind, &argv[optind]); 677 } 678 else 679 { 680 /* OK, that's all the options. */ 681 682 /* The first argument, if specified, is the name of the 683 executable. */ 684 if (optind < argc) 685 { 686 symarg = argv[optind]; 687 execarg = argv[optind]; 688 optind++; 689 } 690 691 /* If the user hasn't already specified a PID or the name of a 692 core file, then a second optional argument is allowed. If 693 present, this argument should be interpreted as either a 694 PID or a core file, whichever works. */ 695 if (pidarg == NULL && corearg == NULL && optind < argc) 696 { 697 pid_or_core_arg = argv[optind]; 698 optind++; 699 } 700 701 /* Any argument left on the command line is unexpected and 702 will be ignored. Inform the user. */ 703 if (optind < argc) 704 fprintf_unfiltered (gdb_stderr, _("\ 705 Excess command line arguments ignored. (%s%s)\n"), 706 argv[optind], 707 (optind == argc - 1) ? "" : " ..."); 708 } 709 710 /* Lookup gdbinit files. Note that the gdbinit file name may be overriden 711 during file initialization, so get_init_files should be called after 712 gdb_init. */ 713 get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit); 714 715 /* Do these (and anything which might call wrap_here or *_filtered) 716 after initialize_all_files() but before the interpreter has been 717 installed. Otherwize the help/version messages will be eaten by 718 the interpreter's output handler. */ 719 720 if (print_version) 721 { 722 print_gdb_version (gdb_stdout); 723 wrap_here (""); 724 printf_filtered ("\n"); 725 exit (0); 726 } 727 728 if (print_help) 729 { 730 print_gdb_help (gdb_stdout); 731 fputs_unfiltered ("\n", gdb_stdout); 732 exit (0); 733 } 734 735 /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets 736 GDB retain the old MI1 interpreter startup behavior. Output the 737 copyright message before the interpreter is installed. That way 738 it isn't encapsulated in MI output. */ 739 if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0) 740 { 741 /* Print all the junk at the top, with trailing "..." if we are about 742 to read a symbol file (possibly slowly). */ 743 print_gdb_version (gdb_stdout); 744 if (symarg) 745 printf_filtered (".."); 746 wrap_here (""); 747 printf_filtered ("\n"); 748 gdb_flush (gdb_stdout); /* Force to screen during slow operations */ 749 } 750 751 752 /* Install the default UI. All the interpreters should have had a 753 look at things by now. Initialize the default interpreter. */ 754 755 { 756 /* Find it. */ 757 struct interp *interp = interp_lookup (interpreter_p); 758 759 if (interp == NULL) 760 error (_("Interpreter `%s' unrecognized"), interpreter_p); 761 /* Install it. */ 762 if (!interp_set (interp, 1)) 763 { 764 fprintf_unfiltered (gdb_stderr, 765 "Interpreter `%s' failed to initialize.\n", 766 interpreter_p); 767 exit (1); 768 } 769 } 770 771 /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets 772 GDB retain the old MI1 interpreter startup behavior. Output the 773 copyright message after the interpreter is installed when it is 774 any sane interpreter. */ 775 if (!quiet && !current_interp_named_p (INTERP_MI1)) 776 { 777 /* Print all the junk at the top, with trailing "..." if we are about 778 to read a symbol file (possibly slowly). */ 779 print_gdb_version (gdb_stdout); 780 if (symarg) 781 printf_filtered (".."); 782 wrap_here (""); 783 printf_filtered ("\n"); 784 gdb_flush (gdb_stdout); /* Force to screen during slow operations */ 785 } 786 787 /* Set off error and warning messages with a blank line. */ 788 error_pre_print = "\n"; 789 quit_pre_print = error_pre_print; 790 warning_pre_print = _("\nwarning: "); 791 792 /* Read and execute the system-wide gdbinit file, if it exists. 793 This is done *before* all the command line arguments are 794 processed; it sets global parameters, which are independent of 795 what file you are debugging or what directory you are in. */ 796 if (system_gdbinit && !inhibit_gdbinit) 797 catch_command_errors (source_script, system_gdbinit, 0, RETURN_MASK_ALL); 798 799 /* Read and execute $HOME/.gdbinit file, if it exists. This is done 800 *before* all the command line arguments are processed; it sets 801 global parameters, which are independent of what file you are 802 debugging or what directory you are in. */ 803 804 if (home_gdbinit && !inhibit_gdbinit) 805 catch_command_errors (source_script, home_gdbinit, 0, RETURN_MASK_ALL); 806 807 /* Now perform all the actions indicated by the arguments. */ 808 if (cdarg != NULL) 809 { 810 catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL); 811 } 812 813 for (i = 0; i < ndir; i++) 814 catch_command_errors (directory_switch, dirarg[i], 0, RETURN_MASK_ALL); 815 xfree (dirarg); 816 817 /* Skip auto-loading section-specified scripts until we've sourced 818 local_gdbinit (which is often used to augment the source search path). */ 819 save_auto_load = gdbpy_global_auto_load; 820 gdbpy_global_auto_load = 0; 821 822 if (execarg != NULL 823 && symarg != NULL 824 && strcmp (execarg, symarg) == 0) 825 { 826 /* The exec file and the symbol-file are the same. If we can't 827 open it, better only print one error message. 828 catch_command_errors returns non-zero on success! */ 829 if (catch_command_errors (exec_file_attach, execarg, !batch_flag, RETURN_MASK_ALL)) 830 catch_command_errors (symbol_file_add_main, symarg, !batch_flag, RETURN_MASK_ALL); 831 } 832 else 833 { 834 if (execarg != NULL) 835 catch_command_errors (exec_file_attach, execarg, !batch_flag, RETURN_MASK_ALL); 836 if (symarg != NULL) 837 catch_command_errors (symbol_file_add_main, symarg, !batch_flag, RETURN_MASK_ALL); 838 } 839 840 if (corearg && pidarg) 841 error (_("\ 842 Can't attach to process and specify a core file at the same time.")); 843 844 if (corearg != NULL) 845 catch_command_errors (core_file_command, corearg, 846 !batch_flag, RETURN_MASK_ALL); 847 else if (pidarg != NULL) 848 catch_command_errors (attach_command, pidarg, 849 !batch_flag, RETURN_MASK_ALL); 850 else if (pid_or_core_arg) 851 { 852 /* The user specified 'gdb program pid' or gdb program core'. 853 If pid_or_core_arg's first character is a digit, try attach 854 first and then corefile. Otherwise try just corefile. */ 855 856 if (isdigit (pid_or_core_arg[0])) 857 { 858 if (catch_command_errors (attach_command, pid_or_core_arg, 859 !batch_flag, RETURN_MASK_ALL) == 0) 860 catch_command_errors (core_file_command, pid_or_core_arg, 861 !batch_flag, RETURN_MASK_ALL); 862 } 863 else /* Can't be a pid, better be a corefile. */ 864 catch_command_errors (core_file_command, pid_or_core_arg, 865 !batch_flag, RETURN_MASK_ALL); 866 } 867 868 if (ttyarg != NULL) 869 set_inferior_io_terminal (ttyarg); 870 871 /* Error messages should no longer be distinguished with extra output. */ 872 error_pre_print = NULL; 873 quit_pre_print = NULL; 874 warning_pre_print = _("warning: "); 875 876 /* Read the .gdbinit file in the current directory, *if* it isn't 877 the same as the $HOME/.gdbinit file (it should exist, also). */ 878 if (local_gdbinit && !inhibit_gdbinit) 879 catch_command_errors (source_script, local_gdbinit, 0, RETURN_MASK_ALL); 880 881 /* Now that all .gdbinit's have been read and all -d options have been 882 processed, we can read any scripts mentioned in SYMARG. 883 We wait until now because it is common to add to the source search 884 path in local_gdbinit. */ 885 gdbpy_global_auto_load = save_auto_load; 886 if (symfile_objfile != NULL) 887 load_auto_scripts_for_objfile (symfile_objfile); 888 889 for (i = 0; i < ncmd; i++) 890 { 891 if (cmdarg[i].type == CMDARG_FILE) 892 catch_command_errors (source_script, cmdarg[i].string, 893 !batch_flag, RETURN_MASK_ALL); 894 else /* cmdarg[i].type == CMDARG_COMMAND */ 895 catch_command_errors (execute_command, cmdarg[i].string, 896 !batch_flag, RETURN_MASK_ALL); 897 } 898 xfree (cmdarg); 899 900 /* Read in the old history after all the command files have been read. */ 901 init_history (); 902 903 if (batch_flag) 904 { 905 /* We have hit the end of the batch file. */ 906 quit_force (NULL, 0); 907 } 908 909 /* Show time and/or space usage. */ 910 do_cleanups (pre_stat_chain); 911 912 /* NOTE: cagney/1999-11-07: There is probably no reason for not 913 moving this loop and the code found in captured_command_loop() 914 into the command_loop() proper. The main thing holding back that 915 change - SET_TOP_LEVEL() - has been eliminated. */ 916 while (1) 917 { 918 catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL); 919 } 920 /* No exit -- exit is through quit_command. */ 921 } 922 923 int 924 gdb_main (struct captured_main_args *args) 925 { 926 kernel_debugger = 0; 927 use_windows = args->use_windows; 928 catch_errors (captured_main, args, "", RETURN_MASK_ALL); 929 /* The only way to end up here is by an error (normal exit is 930 handled by quit_force()), hence always return an error status. */ 931 return 1; 932 } 933 934 935 /* Don't use *_filtered for printing help. We don't want to prompt 936 for continue no matter how small the screen or how much we're going 937 to print. */ 938 939 static void 940 print_gdb_help (struct ui_file *stream) 941 { 942 char *system_gdbinit; 943 char *home_gdbinit; 944 char *local_gdbinit; 945 946 get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit); 947 948 fputs_unfiltered (_("\ 949 This is the GNU debugger. Usage:\n\n\ 950 gdb [options] [executable-file [core-file or process-id]]\n\ 951 gdb [options] --args executable-file [inferior-arguments ...]\n\n\ 952 Options:\n\n\ 953 "), stream); 954 fputs_unfiltered (_("\ 955 --args Arguments after executable-file are passed to inferior\n\ 956 "), stream); 957 fputs_unfiltered (_("\ 958 -b BAUDRATE Set serial port baud rate used for remote debugging.\n\ 959 --batch Exit after processing options.\n\ 960 --batch-silent As for --batch, but suppress all gdb stdout output.\n\ 961 --return-child-result\n\ 962 GDB exit code will be the child's exit code.\n\ 963 --cd=DIR Change current directory to DIR.\n\ 964 --command=FILE, -x Execute GDB commands from FILE.\n\ 965 --eval-command=COMMAND, -ex\n\ 966 Execute a single GDB command.\n\ 967 May be used multiple times and in conjunction\n\ 968 with --command.\n\ 969 --core=COREFILE Analyze the core dump COREFILE.\n\ 970 --pid=PID Attach to running process PID.\n\ 971 "), stream); 972 fputs_unfiltered (_("\ 973 --dbx DBX compatibility mode.\n\ 974 --directory=DIR Search for source files in DIR.\n\ 975 --epoch Output information used by epoch emacs-GDB interface.\n\ 976 --exec=EXECFILE Use EXECFILE as the executable.\n\ 977 --fullname Output information used by emacs-GDB interface.\n\ 978 --help Print this message.\n\ 979 "), stream); 980 fputs_unfiltered (_("\ 981 --interpreter=INTERP\n\ 982 Select a specific interpreter / user interface\n\ 983 "), stream); 984 fputs_unfiltered (_("\ 985 -l TIMEOUT Set timeout in seconds for remote debugging.\n\ 986 --nw Do not use a window interface.\n\ 987 --nx Do not read "), stream); 988 fputs_unfiltered (gdbinit, stream); 989 fputs_unfiltered (_(" file.\n\ 990 --quiet Do not print version number on startup.\n\ 991 --readnow Fully read symbol files on first access.\n\ 992 "), stream); 993 fputs_unfiltered (_("\ 994 --se=FILE Use FILE as symbol file and executable file.\n\ 995 --symbols=SYMFILE Read symbols from SYMFILE.\n\ 996 --tty=TTY Use TTY for input/output by the program being debugged.\n\ 997 "), stream); 998 #if defined(TUI) 999 fputs_unfiltered (_("\ 1000 --tui Use a terminal user interface.\n\ 1001 "), stream); 1002 #endif 1003 fputs_unfiltered (_("\ 1004 --version Print version information and then exit.\n\ 1005 -w Use a window interface.\n\ 1006 --write Set writing into executable and core files.\n\ 1007 --xdb XDB compatibility mode.\n\ 1008 "), stream); 1009 fputs_unfiltered (_("\n\ 1010 At startup, GDB reads the following init files and executes their commands:\n\ 1011 "), stream); 1012 if (system_gdbinit) 1013 fprintf_unfiltered (stream, _("\ 1014 * system-wide init file: %s\n\ 1015 "), system_gdbinit); 1016 if (home_gdbinit) 1017 fprintf_unfiltered (stream, _("\ 1018 * user-specific init file: %s\n\ 1019 "), home_gdbinit); 1020 if (local_gdbinit) 1021 fprintf_unfiltered (stream, _("\ 1022 * local init file: ./%s\n\ 1023 "), local_gdbinit); 1024 fputs_unfiltered (_("\n\ 1025 For more information, type \"help\" from within GDB, or consult the\n\ 1026 GDB manual (available as on-line info or a printed manual).\n\ 1027 "), stream); 1028 if (REPORT_BUGS_TO[0] && stream == gdb_stdout) 1029 fprintf_unfiltered (stream, _("\ 1030 Report bugs to \"%s\".\n\ 1031 "), REPORT_BUGS_TO); 1032 } 1033