gdb/main.c

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