gdb/main.c

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