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