contrib/gdb-7/gdb/main.c

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