gdb/main.c

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