gdb/main.c

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