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