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