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