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