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