gdb/main.c

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