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