gdb/main.c

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