gdb/main.c

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