gdb/main.c

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