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