gdb/main.c

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