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