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