gdb/main.c

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