gdb/main.c

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