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