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