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