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