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   make_cleanup (VEC_cleanup (cmdarg_s), &cmdarg_vec);
 361   dirsize = 1;
 362   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
 363   ndir = 0;
 364
 365   clear_quit_flag ();
 366   saved_command_line = (char *) xmalloc (saved_command_line_size);
 367   saved_command_line[0] = '\0';
 368   instream = stdin;
 369
 370   gdb_stdout = stdio_fileopen (stdout);
 371   gdb_stderr = stdio_fileopen (stderr);
 372   gdb_stdlog = gdb_stderr;      /* for moment */
 373   gdb_stdtarg = gdb_stderr;     /* for moment */
 374   gdb_stdin = stdio_fileopen (stdin);
 375   gdb_stdtargerr = gdb_stderr;  /* for moment */
 376   gdb_stdtargin = gdb_stdin;    /* for moment */
 377
 378   gdb_program_name = xstrdup (argv[0]);
 379
 380   if (! getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)))
 381     /* Don't use *_filtered or warning() (which relies on
 382        current_target) until after initialize_all_files().  */
 383     fprintf_unfiltered (gdb_stderr,
 384                         _("%s: warning: error finding "
 385                           "working directory: %s\n"),
 386                         argv[0], safe_strerror (errno));
 387
 388   current_directory = gdb_dirbuf;
 389
 390   /* Set the sysroot path.  */
 391   gdb_sysroot = relocate_gdb_directory (TARGET_SYSTEM_ROOT,
 392                                         TARGET_SYSTEM_ROOT_RELOCATABLE);
 393
 394   debug_file_directory = relocate_gdb_directory (DEBUGDIR,
 395                                                  DEBUGDIR_RELOCATABLE);
 396
 397   gdb_datadir = relocate_gdb_directory (GDB_DATADIR,
 398                                         GDB_DATADIR_RELOCATABLE);
 399
 400 #ifdef WITH_PYTHON_PATH
 401   {
 402     /* For later use in helping Python find itself.  */
 403     char *tmp = concat (WITH_PYTHON_PATH, SLASH_STRING, "lib", NULL);
 404
 405     python_libdir = relocate_gdb_directory (tmp, PYTHON_PATH_RELOCATABLE);
 406     xfree (tmp);
 407   }
 408 #endif
 409
 410 #ifdef RELOC_SRCDIR
 411   add_substitute_path_rule (RELOC_SRCDIR,
 412                             make_relative_prefix (argv[0], BINDIR,
 413                                                   RELOC_SRCDIR));
 414 #endif
 415
 416   /* There will always be an interpreter.  Either the one passed into
 417      this captured main, or one specified by the user at start up, or
 418      the console.  Initialize the interpreter to the one requested by
 419      the application.  */
 420   interpreter_p = xstrdup (context->interpreter_p);
 421
 422   /* Parse arguments and options.  */
 423   {
 424     int c;
 425     /* When var field is 0, use flag field to record the equivalent
 426        short option (or arbitrary numbers starting at 10 for those
 427        with no equivalent).  */
 428     enum {
 429       OPT_SE = 10,
 430       OPT_CD,
 431       OPT_ANNOTATE,
 432       OPT_STATISTICS,
 433       OPT_TUI,
 434       OPT_NOWINDOWS,
 435       OPT_WINDOWS,
 436       OPT_IX,
 437       OPT_IEX
 438     };
 439     static struct option long_options[] =
 440     {
 441       {"tui", no_argument, 0, OPT_TUI},
 442       {"xdb", no_argument, &xdb_commands, 1},
 443       {"dbx", no_argument, &dbx_commands, 1},
 444       {"readnow", no_argument, &readnow_symbol_files, 1},
 445       {"r", no_argument, &readnow_symbol_files, 1},
 446       {"quiet", no_argument, &quiet, 1},
 447       {"q", no_argument, &quiet, 1},
 448       {"silent", no_argument, &quiet, 1},
 449       {"nh", no_argument, &inhibit_home_gdbinit, 1},
 450       {"nx", no_argument, &inhibit_gdbinit, 1},
 451       {"n", no_argument, &inhibit_gdbinit, 1},
 452       {"batch-silent", no_argument, 0, 'B'},
 453       {"batch", no_argument, &batch_flag, 1},
 454       {"epoch", no_argument, &epoch_interface, 1},
 455
 456     /* This is a synonym for "--annotate=1".  --annotate is now
 457        preferred, but keep this here for a long time because people
 458        will be running emacses which use --fullname.  */
 459       {"fullname", no_argument, 0, 'f'},
 460       {"f", no_argument, 0, 'f'},
 461
 462       {"annotate", required_argument, 0, OPT_ANNOTATE},
 463       {"help", no_argument, &print_help, 1},
 464       {"se", required_argument, 0, OPT_SE},
 465       {"symbols", required_argument, 0, 's'},
 466       {"s", required_argument, 0, 's'},
 467       {"exec", required_argument, 0, 'e'},
 468       {"e", required_argument, 0, 'e'},
 469       {"core", required_argument, 0, 'c'},
 470       {"c", required_argument, 0, 'c'},
 471       {"pid", required_argument, 0, 'p'},
 472       {"p", required_argument, 0, 'p'},
 473       {"command", required_argument, 0, 'x'},
 474       {"eval-command", required_argument, 0, 'X'},
 475       {"version", no_argument, &print_version, 1},
 476       {"x", required_argument, 0, 'x'},
 477       {"ex", required_argument, 0, 'X'},
 478       {"init-command", required_argument, 0, OPT_IX},
 479       {"init-eval-command", required_argument, 0, OPT_IEX},
 480       {"ix", required_argument, 0, OPT_IX},
 481       {"iex", required_argument, 0, OPT_IEX},
 482 #ifdef GDBTK
 483       {"tclcommand", required_argument, 0, 'z'},
 484       {"enable-external-editor", no_argument, 0, 'y'},
 485       {"editor-command", required_argument, 0, 'w'},
 486 #endif
 487       {"ui", required_argument, 0, 'i'},
 488       {"interpreter", required_argument, 0, 'i'},
 489       {"i", required_argument, 0, 'i'},
 490       {"directory", required_argument, 0, 'd'},
 491       {"d", required_argument, 0, 'd'},
 492       {"data-directory", required_argument, 0, 'D'},
 493       {"cd", required_argument, 0, OPT_CD},
 494       {"tty", required_argument, 0, 't'},
 495       {"baud", required_argument, 0, 'b'},
 496       {"b", required_argument, 0, 'b'},
 497       {"nw", no_argument, NULL, OPT_NOWINDOWS},
 498       {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
 499       {"w", no_argument, NULL, OPT_WINDOWS},
 500       {"windows", no_argument, NULL, OPT_WINDOWS},
 501       {"statistics", no_argument, 0, OPT_STATISTICS},
 502       {"write", no_argument, &write_files, 1},
 503       {"args", no_argument, &set_args, 1},
 504       {"l", required_argument, 0, 'l'},
 505       {"return-child-result", no_argument, &return_child_result, 1},
 506       {0, no_argument, 0, 0}
 507     };
 508
 509     while (1)
 510       {
 511         int option_index;
 512
 513         c = getopt_long_only (argc, argv, "",
 514                               long_options, &option_index);
 515         if (c == EOF || set_args)
 516           break;
 517
 518         /* Long option that takes an argument.  */
 519         if (c == 0 && long_options[option_index].flag == 0)
 520           c = long_options[option_index].val;
 521
 522         switch (c)
 523           {
 524           case 0:
 525             /* Long option that just sets a flag.  */
 526             break;
 527           case OPT_SE:
 528             symarg = optarg;
 529             execarg = optarg;
 530             break;
 531           case OPT_CD:
 532             cdarg = optarg;
 533             break;
 534           case OPT_ANNOTATE:
 535             /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
 536             annotation_level = atoi (optarg);
 537             break;
 538           case OPT_STATISTICS:
 539             /* Enable the display of both time and space usage.  */
 540             set_display_time (1);
 541             set_display_space (1);
 542             break;
 543           case OPT_TUI:
 544             /* --tui is equivalent to -i=tui.  */
 545 #ifdef TUI
 546             xfree (interpreter_p);
 547             interpreter_p = xstrdup (INTERP_TUI);
 548 #else
 549             fprintf_unfiltered (gdb_stderr,
 550                                 _("%s: TUI mode is not supported\n"),
 551                                 argv[0]);
 552             exit (1);
 553 #endif
 554             break;
 555           case OPT_WINDOWS:
 556             /* FIXME: cagney/2003-03-01: Not sure if this option is
 557                actually useful, and if it is, what it should do.  */
 558 #ifdef GDBTK
 559             /* --windows is equivalent to -i=insight.  */
 560             xfree (interpreter_p);
 561             interpreter_p = xstrdup (INTERP_INSIGHT);
 562 #endif
 563             use_windows = 1;
 564             break;
 565           case OPT_NOWINDOWS:
 566             /* -nw is equivalent to -i=console.  */
 567             xfree (interpreter_p);
 568             interpreter_p = xstrdup (INTERP_CONSOLE);
 569             use_windows = 0;
 570             break;
 571           case 'f':
 572             annotation_level = 1;
 573             /* We have probably been invoked from emacs.  Disable
 574                window interface.  */
 575             use_windows = 0;
 576             break;
 577           case 's':
 578             symarg = optarg;
 579             break;
 580           case 'e':
 581             execarg = optarg;
 582             break;
 583           case 'c':
 584             corearg = optarg;
 585             break;
 586           case 'p':
 587             pidarg = optarg;
 588             break;
 589           case 'x':
 590             {
 591               struct cmdarg cmdarg = { CMDARG_FILE, optarg };
 592
 593               VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
 594             }
 595             break;
 596           case 'X':
 597             {
 598               struct cmdarg cmdarg = { CMDARG_COMMAND, optarg };
 599
 600               VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
 601             }
 602             break;
 603           case OPT_IX:
 604             {
 605               struct cmdarg cmdarg = { CMDARG_INIT_FILE, optarg };
 606
 607               VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
 608             }
 609             break;
 610           case OPT_IEX:
 611             {
 612               struct cmdarg cmdarg = { CMDARG_INIT_COMMAND, optarg };
 613
 614               VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
 615             }
 616             break;
 617           case 'B':
 618             batch_flag = batch_silent = 1;
 619             gdb_stdout = ui_file_new();
 620             break;
 621           case 'D':
 622             xfree (gdb_datadir);
 623             gdb_datadir = xstrdup (optarg);
 624             gdb_datadir_provided = 1;
 625             break;
 626 #ifdef GDBTK
 627           case 'z':
 628             {
 629               extern int gdbtk_test (char *);
 630
 631               if (!gdbtk_test (optarg))
 632                 {
 633                   fprintf_unfiltered (gdb_stderr,
 634                                       _("%s: unable to load "
 635                                         "tclcommand file \"%s\""),
 636                                       argv[0], optarg);
 637                   exit (1);
 638                 }
 639               break;
 640             }
 641           case 'y':
 642             /* Backwards compatibility only.  */
 643             break;
 644           case 'w':
 645             {
 646               /* Set the external editor commands when gdb is farming out files
 647                  to be edited by another program.  */
 648               extern char *external_editor_command;
 649
 650               external_editor_command = xstrdup (optarg);
 651               break;
 652             }
 653 #endif /* GDBTK */
 654           case 'i':
 655             xfree (interpreter_p);
 656             interpreter_p = xstrdup (optarg);
 657             break;
 658           case 'd':
 659             dirarg[ndir++] = optarg;
 660             if (ndir >= dirsize)
 661               {
 662                 dirsize *= 2;
 663                 dirarg = (char **) xrealloc ((char *) dirarg,
 664                                              dirsize * sizeof (*dirarg));
 665               }
 666             break;
 667           case 't':
 668             ttyarg = optarg;
 669             break;
 670           case 'q':
 671             quiet = 1;
 672             break;
 673           case 'b':
 674             {
 675               int i;
 676               char *p;
 677
 678               i = strtol (optarg, &p, 0);
 679               if (i == 0 && p == optarg)
 680
 681                 /* Don't use *_filtered or warning() (which relies on
 682                    current_target) until after initialize_all_files().  */
 683
 684                 fprintf_unfiltered
 685                   (gdb_stderr,
 686                    _("warning: could not set baud rate to `%s'.\n"), optarg);
 687               else
 688                 baud_rate = i;
 689             }
 690             break;
 691           case 'l':
 692             {
 693               int i;
 694               char *p;
 695
 696               i = strtol (optarg, &p, 0);
 697               if (i == 0 && p == optarg)
 698
 699                 /* Don't use *_filtered or warning() (which relies on
 700                    current_target) until after initialize_all_files().  */
 701
 702                 fprintf_unfiltered (gdb_stderr,
 703                                     _("warning: could not set "
 704                                       "timeout limit to `%s'.\n"), optarg);
 705               else
 706                 remote_timeout = i;
 707             }
 708             break;
 709
 710           case '?':
 711             fprintf_unfiltered (gdb_stderr,
 712                                 _("Use `%s --help' for a "
 713                                   "complete list of options.\n"),
 714                                 argv[0]);
 715             exit (1);
 716           }
 717       }
 718
 719     /* If --help or --version, disable window interface.  */
 720     if (print_help || print_version)
 721       {
 722         use_windows = 0;
 723       }
 724
 725     if (batch_flag)
 726       quiet = 1;
 727   }
 728
 729   /* Initialize all files.  Give the interpreter a chance to take
 730      control of the console via the deprecated_init_ui_hook ().  */
 731   gdb_init (argv[0]);
 732
 733   /* Now that gdb_init has created the initial inferior, we're in
 734      position to set args for that inferior.  */
 735   if (set_args)
 736     {
 737       /* The remaining options are the command-line options for the
 738          inferior.  The first one is the sym/exec file, and the rest
 739          are arguments.  */
 740       if (optind >= argc)
 741         {
 742           fprintf_unfiltered (gdb_stderr,
 743                               _("%s: `--args' specified but "
 744                                 "no program specified\n"),
 745                               argv[0]);
 746           exit (1);
 747         }
 748       symarg = argv[optind];
 749       execarg = argv[optind];
 750       ++optind;
 751       set_inferior_args_vector (argc - optind, &argv[optind]);
 752     }
 753   else
 754     {
 755       /* OK, that's all the options.  */
 756
 757       /* The first argument, if specified, is the name of the
 758          executable.  */
 759       if (optind < argc)
 760         {
 761           symarg = argv[optind];
 762           execarg = argv[optind];
 763           optind++;
 764         }
 765
 766       /* If the user hasn't already specified a PID or the name of a
 767          core file, then a second optional argument is allowed.  If
 768          present, this argument should be interpreted as either a
 769          PID or a core file, whichever works.  */
 770       if (pidarg == NULL && corearg == NULL && optind < argc)
 771         {
 772           pid_or_core_arg = argv[optind];
 773           optind++;
 774         }
 775
 776       /* Any argument left on the command line is unexpected and
 777          will be ignored.  Inform the user.  */
 778       if (optind < argc)
 779         fprintf_unfiltered (gdb_stderr,
 780                             _("Excess command line "
 781                               "arguments ignored. (%s%s)\n"),
 782                             argv[optind],
 783                             (optind == argc - 1) ? "" : " ...");
 784     }
 785
 786   /* Lookup gdbinit files.  Note that the gdbinit file name may be
 787      overriden during file initialization, so get_init_files should be
 788      called after gdb_init.  */
 789   get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
 790
 791   /* Do these (and anything which might call wrap_here or *_filtered)
 792      after initialize_all_files() but before the interpreter has been
 793      installed.  Otherwize the help/version messages will be eaten by
 794      the interpreter's output handler.  */
 795
 796   if (print_version)
 797     {
 798       print_gdb_version (gdb_stdout);
 799       wrap_here ("");
 800       printf_filtered ("\n");
 801       exit (0);
 802     }
 803
 804   if (print_help)
 805     {
 806       print_gdb_help (gdb_stdout);
 807       fputs_unfiltered ("\n", gdb_stdout);
 808       exit (0);
 809     }
 810
 811   /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
 812      GDB retain the old MI1 interpreter startup behavior.  Output the
 813      copyright message before the interpreter is installed.  That way
 814      it isn't encapsulated in MI output.  */
 815   if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
 816     {
 817       /* Print all the junk at the top, with trailing "..." if we are
 818          about to read a symbol file (possibly slowly).  */
 819       print_gdb_version (gdb_stdout);
 820       if (symarg)
 821         printf_filtered ("..");
 822       wrap_here ("");
 823       printf_filtered ("\n");
 824       gdb_flush (gdb_stdout);   /* Force to screen during slow
 825                                    operations.  */
 826     }
 827
 828   /* Install the default UI.  All the interpreters should have had a
 829      look at things by now.  Initialize the default interpreter.  */
 830
 831   {
 832     /* Find it.  */
 833     struct interp *interp = interp_lookup (interpreter_p);
 834
 835     if (interp == NULL)
 836       error (_("Interpreter `%s' unrecognized"), interpreter_p);
 837     /* Install it.  */
 838     if (!interp_set (interp, 1))
 839       {
 840         fprintf_unfiltered (gdb_stderr,
 841                             "Interpreter `%s' failed to initialize.\n",
 842                             interpreter_p);
 843         exit (1);
 844       }
 845   }
 846
 847   /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
 848      GDB retain the old MI1 interpreter startup behavior.  Output the
 849      copyright message after the interpreter is installed when it is
 850      any sane interpreter.  */
 851   if (!quiet && !current_interp_named_p (INTERP_MI1))
 852     {
 853       /* Print all the junk at the top, with trailing "..." if we are
 854          about to read a symbol file (possibly slowly).  */
 855       print_gdb_version (gdb_stdout);
 856       if (symarg)
 857         printf_filtered ("..");
 858       wrap_here ("");
 859       printf_filtered ("\n");
 860       gdb_flush (gdb_stdout);   /* Force to screen during slow
 861                                    operations.  */
 862     }
 863
 864   /* Set off error and warning messages with a blank line.  */
 865   error_pre_print = "\n";
 866   quit_pre_print = error_pre_print;
 867   warning_pre_print = _("\nwarning: ");
 868
 869   /* Read and execute the system-wide gdbinit file, if it exists.
 870      This is done *before* all the command line arguments are
 871      processed; it sets global parameters, which are independent of
 872      what file you are debugging or what directory you are in.  */
 873   if (system_gdbinit && !inhibit_gdbinit)
 874     catch_command_errors (source_script, system_gdbinit, 0, RETURN_MASK_ALL);
 875
 876   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
 877      *before* all the command line arguments are processed; it sets
 878      global parameters, which are independent of what file you are
 879      debugging or what directory you are in.  */
 880
 881   if (home_gdbinit && !inhibit_gdbinit && !inhibit_home_gdbinit)
 882     catch_command_errors (source_script, home_gdbinit, 0, RETURN_MASK_ALL);
 883
 884   /* Process '-ix' and '-iex' options early.  */
 885   for (i = 0; VEC_iterate (cmdarg_s, cmdarg_vec, i, cmdarg_p); i++)
 886     switch (cmdarg_p->type)
 887     {
 888       case CMDARG_INIT_FILE:
 889         catch_command_errors (source_script, cmdarg_p->string,
 890                               !batch_flag, RETURN_MASK_ALL);
 891         break;
 892       case CMDARG_INIT_COMMAND:
 893         catch_command_errors (execute_command, cmdarg_p->string,
 894                               !batch_flag, RETURN_MASK_ALL);
 895         break;
 896     }
 897
 898   /* Now perform all the actions indicated by the arguments.  */
 899   if (cdarg != NULL)
 900     {
 901       catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
 902     }
 903
 904   for (i = 0; i < ndir; i++)
 905     catch_command_errors (directory_switch, dirarg[i], 0, RETURN_MASK_ALL);
 906   xfree (dirarg);
 907
 908   /* Skip auto-loading section-specified scripts until we've sourced
 909      local_gdbinit (which is often used to augment the source search
 910      path).  */
 911   save_auto_load = global_auto_load;
 912   global_auto_load = 0;
 913
 914   if (execarg != NULL
 915       && symarg != NULL
 916       && strcmp (execarg, symarg) == 0)
 917     {
 918       /* The exec file and the symbol-file are the same.  If we can't
 919          open it, better only print one error message.
 920          catch_command_errors returns non-zero on success!  */
 921       if (catch_command_errors (exec_file_attach, execarg,
 922                                 !batch_flag, RETURN_MASK_ALL))
 923         catch_command_errors (symbol_file_add_main, symarg,
 924                               !batch_flag, RETURN_MASK_ALL);
 925     }
 926   else
 927     {
 928       if (execarg != NULL)
 929         catch_command_errors (exec_file_attach, execarg,
 930                               !batch_flag, RETURN_MASK_ALL);
 931       if (symarg != NULL)
 932         catch_command_errors (symbol_file_add_main, symarg,
 933                               !batch_flag, RETURN_MASK_ALL);
 934     }
 935
 936   if (corearg && pidarg)
 937     error (_("Can't attach to process and specify "
 938              "a core file at the same time."));
 939
 940   if (corearg != NULL)
 941     catch_command_errors (core_file_command, corearg,
 942                           !batch_flag, RETURN_MASK_ALL);
 943   else if (pidarg != NULL)
 944     catch_command_errors (attach_command, pidarg,
 945                           !batch_flag, RETURN_MASK_ALL);
 946   else if (pid_or_core_arg)
 947     {
 948       /* The user specified 'gdb program pid' or gdb program core'.
 949          If pid_or_core_arg's first character is a digit, try attach
 950          first and then corefile.  Otherwise try just corefile.  */
 951
 952       if (isdigit (pid_or_core_arg[0]))
 953         {
 954           if (catch_command_errors (attach_command, pid_or_core_arg,
 955                                     !batch_flag, RETURN_MASK_ALL) == 0)
 956             catch_command_errors (core_file_command, pid_or_core_arg,
 957                                   !batch_flag, RETURN_MASK_ALL);
 958         }
 959       else /* Can't be a pid, better be a corefile.  */
 960         catch_command_errors (core_file_command, pid_or_core_arg,
 961                               !batch_flag, RETURN_MASK_ALL);
 962     }
 963
 964   if (ttyarg != NULL)
 965     set_inferior_io_terminal (ttyarg);
 966
 967   /* Error messages should no longer be distinguished with extra output.  */
 968   error_pre_print = NULL;
 969   quit_pre_print = NULL;
 970   warning_pre_print = _("warning: ");
 971
 972   /* Read the .gdbinit file in the current directory, *if* it isn't
 973      the same as the $HOME/.gdbinit file (it should exist, also).  */
 974   if (local_gdbinit)
 975     {
 976       auto_load_local_gdbinit_pathname = gdb_realpath (local_gdbinit);
 977
 978       if (!inhibit_gdbinit && auto_load_local_gdbinit
 979           && file_is_auto_load_safe (local_gdbinit,
 980                                      _("auto-load: Loading .gdbinit "
 981                                        "file \"%s\".\n"),
 982                                      local_gdbinit))
 983         {
 984           auto_load_local_gdbinit_loaded = 1;
 985
 986           catch_command_errors (source_script, local_gdbinit, 0,
 987                                 RETURN_MASK_ALL);
 988         }
 989     }
 990
 991   /* Now that all .gdbinit's have been read and all -d options have been
 992      processed, we can read any scripts mentioned in SYMARG.
 993      We wait until now because it is common to add to the source search
 994      path in local_gdbinit.  */
 995   global_auto_load = save_auto_load;
 996   ALL_OBJFILES (objfile)
 997     load_auto_scripts_for_objfile (objfile);
 998
 999   /* Process '-x' and '-ex' options.  */
1000   for (i = 0; VEC_iterate (cmdarg_s, cmdarg_vec, i, cmdarg_p); i++)
1001     switch (cmdarg_p->type)
1002     {
1003       case CMDARG_FILE:
1004         catch_command_errors (source_script, cmdarg_p->string,
1005                               !batch_flag, RETURN_MASK_ALL);
1006         break;
1007       case CMDARG_COMMAND:
1008         catch_command_errors (execute_command, cmdarg_p->string,
1009                               !batch_flag, RETURN_MASK_ALL);
1010         break;
1011     }
1012
1013   /* Read in the old history after all the command files have been
1014      read.  */
1015   init_history ();
1016
1017   if (batch_flag)
1018     {
1019       /* We have hit the end of the batch file.  */
1020       quit_force (NULL, 0);
1021     }
1022
1023   /* Show time and/or space usage.  */
1024   do_cleanups (pre_stat_chain);
1025
1026   /* NOTE: cagney/1999-11-07: There is probably no reason for not
1027      moving this loop and the code found in captured_command_loop()
1028      into the command_loop() proper.  The main thing holding back that
1029      change - SET_TOP_LEVEL() - has been eliminated.  */
1030   while (1)
1031     {
1032       catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
1033     }
1034   /* No exit -- exit is through quit_command.  */
1035 }
1036
1037 int
1038 gdb_main (struct captured_main_args *args)
1039 {
1040   use_windows = args->use_windows;
1041   catch_errors (captured_main, args, "", RETURN_MASK_ALL);
1042   /* The only way to end up here is by an error (normal exit is
1043      handled by quit_force()), hence always return an error status.  */
1044   return 1;
1045 }
1046
1047
1048 /* Don't use *_filtered for printing help.  We don't want to prompt
1049    for continue no matter how small the screen or how much we're going
1050    to print.  */
1051
1052 static void
1053 print_gdb_help (struct ui_file *stream)
1054 {
1055   char *system_gdbinit;
1056   char *home_gdbinit;
1057   char *local_gdbinit;
1058
1059   get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
1060
1061   fputs_unfiltered (_("\
1062 This is the GNU debugger.  Usage:\n\n\
1063     gdb [options] [executable-file [core-file or process-id]]\n\
1064     gdb [options] --args executable-file [inferior-arguments ...]\n\n\
1065 Options:\n\n\
1066 "), stream);
1067   fputs_unfiltered (_("\
1068   --args             Arguments after executable-file are passed to inferior\n\
1069 "), stream);
1070   fputs_unfiltered (_("\
1071   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
1072   --batch            Exit after processing options.\n\
1073   --batch-silent     As for --batch, but suppress all gdb stdout output.\n\
1074   --return-child-result\n\
1075                      GDB exit code will be the child's exit code.\n\
1076   --cd=DIR           Change current directory to DIR.\n\
1077   --command=FILE, -x Execute GDB commands from FILE.\n\
1078   --eval-command=COMMAND, -ex\n\
1079                      Execute a single GDB command.\n\
1080                      May be used multiple times and in conjunction\n\
1081                      with --command.\n\
1082   --init-command=FILE, -ix Like -x but execute it before loading inferior.\n\
1083   --init-eval-command=COMMAND, -iex Like -ex but before loading inferior.\n\
1084   --core=COREFILE    Analyze the core dump COREFILE.\n\
1085   --pid=PID          Attach to running process PID.\n\
1086 "), stream);
1087   fputs_unfiltered (_("\
1088   --dbx              DBX compatibility mode.\n\
1089   --directory=DIR    Search for source files in DIR.\n\
1090   --epoch            Output information used by epoch emacs-GDB interface.\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 }