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