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