gdb/main.c

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