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