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