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