gdb/main.c

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