gdb/main.c

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