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 static int
 243 captured_main (void *data)
 244 {
 245   struct captured_main_args *context = data;
 246   int argc = context->argc;
 247   char **argv = context->argv;
 248   static int quiet = 0;
 249   static int set_args = 0;
 250
 251   /* Pointers to various arguments from command line.  */
 252   char *symarg = NULL;
 253   char *execarg = NULL;
 254   char *pidarg = NULL;
 255   char *corearg = NULL;
 256   char *pid_or_core_arg = NULL;
 257   char *cdarg = NULL;
 258   char *ttyarg = NULL;
 259
 260   /* These are static so that we can take their address in an
 261      initializer.  */
 262   static int print_help;
 263   static int print_version;
 264
 265   /* Pointers to all arguments of --command option.  */
 266   struct cmdarg {
 267     enum {
 268       CMDARG_FILE,
 269       CMDARG_COMMAND
 270     } type;
 271     char *string;
 272   } *cmdarg;
 273   /* Allocated size of cmdarg.  */
 274   int cmdsize;
 275   /* Number of elements of cmdarg used.  */
 276   int ncmd;
 277
 278   /* Indices of all arguments of --directory option.  */
 279   char **dirarg;
 280   /* Allocated size.  */
 281   int dirsize;
 282   /* Number of elements used.  */
 283   int ndir;
 284
 285   /* gdb init files.  */
 286   char *system_gdbinit;
 287   char *home_gdbinit;
 288   char *local_gdbinit;
 289
 290   int i;
 291   int save_auto_load;
 292   struct objfile *objfile;
 293
 294   struct cleanup *pre_stat_chain;
 295
 296 #ifdef HAVE_SBRK
 297   /* Set this before calling make_command_stats_cleanup.  */
 298   lim_at_start = (char *) sbrk (0);
 299 #endif
 300
 301   pre_stat_chain = make_command_stats_cleanup (0);
 302
 303 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 304   setlocale (LC_MESSAGES, "");
 305 #endif
 306 #if defined (HAVE_SETLOCALE)
 307   setlocale (LC_CTYPE, "");
 308 #endif
 309   bindtextdomain (PACKAGE, LOCALEDIR);
 310   textdomain (PACKAGE);
 311
 312   cmdsize = 1;
 313   cmdarg = (struct cmdarg *) xmalloc (cmdsize * sizeof (*cmdarg));
 314   ncmd = 0;
 315   dirsize = 1;
 316   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
 317   ndir = 0;
 318
 319   quit_flag = 0;
 320   saved_command_line = (char *) xmalloc (saved_command_line_size);
 321   saved_command_line[0] = '\0';
 322   instream = stdin;
 323
 324   gdb_stdout = stdio_fileopen (stdout);
 325   gdb_stderr = stdio_fileopen (stderr);
 326   gdb_stdlog = gdb_stderr;      /* for moment */
 327   gdb_stdtarg = gdb_stderr;     /* for moment */
 328   gdb_stdin = stdio_fileopen (stdin);
 329   gdb_stdtargerr = gdb_stderr;  /* for moment */
 330   gdb_stdtargin = gdb_stdin;    /* for moment */
 331
 332   gdb_program_name = xstrdup (argv[0]);
 333
 334   if (! getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)))
 335     /* Don't use *_filtered or warning() (which relies on
 336        current_target) until after initialize_all_files().  */
 337     fprintf_unfiltered (gdb_stderr,
 338                         _("%s: warning: error finding "
 339                           "working directory: %s\n"),
 340                         argv[0], safe_strerror (errno));
 341
 342   current_directory = gdb_dirbuf;
 343
 344   /* Set the sysroot path.  */
 345   gdb_sysroot = relocate_gdb_directory (TARGET_SYSTEM_ROOT,
 346                                         TARGET_SYSTEM_ROOT_RELOCATABLE);
 347
 348   debug_file_directory = relocate_gdb_directory (DEBUGDIR,
 349                                                  DEBUGDIR_RELOCATABLE);
 350
 351   gdb_datadir = relocate_gdb_directory (GDB_DATADIR,
 352                                         GDB_DATADIR_RELOCATABLE);
 353
 354 #ifdef WITH_PYTHON_PATH
 355   {
 356     /* For later use in helping Python find itself.  */
 357     char *tmp = concat (WITH_PYTHON_PATH, SLASH_STRING, "lib", NULL);
 358
 359     python_libdir = relocate_gdb_directory (tmp, PYTHON_PATH_RELOCATABLE);
 360     xfree (tmp);
 361   }
 362 #endif
 363
 364 #ifdef RELOC_SRCDIR
 365   add_substitute_path_rule (RELOC_SRCDIR,
 366                             make_relative_prefix (argv[0], BINDIR,
 367                                                   RELOC_SRCDIR));
 368 #endif
 369
 370   /* There will always be an interpreter.  Either the one passed into
 371      this captured main, or one specified by the user at start up, or
 372      the console.  Initialize the interpreter to the one requested by
 373      the application.  */
 374   interpreter_p = xstrdup (context->interpreter_p);
 375
 376   /* Parse arguments and options.  */
 377   {
 378     int c;
 379     /* When var field is 0, use flag field to record the equivalent
 380        short option (or arbitrary numbers starting at 10 for those
 381        with no equivalent).  */
 382     enum {
 383       OPT_SE = 10,
 384       OPT_CD,
 385       OPT_ANNOTATE,
 386       OPT_STATISTICS,
 387       OPT_TUI,
 388       OPT_NOWINDOWS,
 389       OPT_WINDOWS
 390     };
 391     static struct option long_options[] =
 392     {
 393       {"tui", no_argument, 0, OPT_TUI},
 394       {"xdb", no_argument, &xdb_commands, 1},
 395       {"dbx", no_argument, &dbx_commands, 1},
 396       {"readnow", no_argument, &readnow_symbol_files, 1},
 397       {"r", no_argument, &readnow_symbol_files, 1},
 398       {"quiet", no_argument, &quiet, 1},
 399       {"q", no_argument, &quiet, 1},
 400       {"silent", no_argument, &quiet, 1},
 401       {"nx", no_argument, &inhibit_gdbinit, 1},
 402       {"n", no_argument, &inhibit_gdbinit, 1},
 403       {"batch-silent", no_argument, 0, 'B'},
 404       {"batch", no_argument, &batch_flag, 1},
 405       {"epoch", no_argument, &epoch_interface, 1},
 406
 407     /* This is a synonym for "--annotate=1".  --annotate is now
 408        preferred, but keep this here for a long time because people
 409        will be running emacses which use --fullname.  */
 410       {"fullname", no_argument, 0, 'f'},
 411       {"f", no_argument, 0, 'f'},
 412
 413       {"annotate", required_argument, 0, OPT_ANNOTATE},
 414       {"help", no_argument, &print_help, 1},
 415       {"se", required_argument, 0, OPT_SE},
 416       {"symbols", required_argument, 0, 's'},
 417       {"s", required_argument, 0, 's'},
 418       {"exec", required_argument, 0, 'e'},
 419       {"e", required_argument, 0, 'e'},
 420       {"core", required_argument, 0, 'c'},
 421       {"c", required_argument, 0, 'c'},
 422       {"pid", required_argument, 0, 'p'},
 423       {"p", required_argument, 0, 'p'},
 424       {"command", required_argument, 0, 'x'},
 425       {"eval-command", required_argument, 0, 'X'},
 426       {"version", no_argument, &print_version, 1},
 427       {"x", required_argument, 0, 'x'},
 428       {"ex", required_argument, 0, 'X'},
 429 #ifdef GDBTK
 430       {"tclcommand", required_argument, 0, 'z'},
 431       {"enable-external-editor", no_argument, 0, 'y'},
 432       {"editor-command", required_argument, 0, 'w'},
 433 #endif
 434       {"ui", required_argument, 0, 'i'},
 435       {"interpreter", required_argument, 0, 'i'},
 436       {"i", required_argument, 0, 'i'},
 437       {"directory", required_argument, 0, 'd'},
 438       {"d", required_argument, 0, 'd'},
 439       {"data-directory", required_argument, 0, 'D'},
 440       {"cd", required_argument, 0, OPT_CD},
 441       {"tty", required_argument, 0, 't'},
 442       {"baud", required_argument, 0, 'b'},
 443       {"b", required_argument, 0, 'b'},
 444       {"nw", no_argument, NULL, OPT_NOWINDOWS},
 445       {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
 446       {"w", no_argument, NULL, OPT_WINDOWS},
 447       {"windows", no_argument, NULL, OPT_WINDOWS},
 448       {"statistics", no_argument, 0, OPT_STATISTICS},
 449       {"write", no_argument, &write_files, 1},
 450       {"args", no_argument, &set_args, 1},
 451       {"l", required_argument, 0, 'l'},
 452       {"return-child-result", no_argument, &return_child_result, 1},
 453       {0, no_argument, 0, 0}
 454     };
 455
 456     while (1)
 457       {
 458         int option_index;
 459
 460         c = getopt_long_only (argc, argv, "",
 461                               long_options, &option_index);
 462         if (c == EOF || set_args)
 463           break;
 464
 465         /* Long option that takes an argument.  */
 466         if (c == 0 && long_options[option_index].flag == 0)
 467           c = long_options[option_index].val;
 468
 469         switch (c)
 470           {
 471           case 0:
 472             /* Long option that just sets a flag.  */
 473             break;
 474           case OPT_SE:
 475             symarg = optarg;
 476             execarg = optarg;
 477             break;
 478           case OPT_CD:
 479             cdarg = optarg;
 480             break;
 481           case OPT_ANNOTATE:
 482             /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
 483             annotation_level = atoi (optarg);
 484             break;
 485           case OPT_STATISTICS:
 486             /* Enable the display of both time and space usage.  */
 487             set_display_time (1);
 488             set_display_space (1);
 489             break;
 490           case OPT_TUI:
 491             /* --tui is equivalent to -i=tui.  */
 492 #ifdef TUI
 493             xfree (interpreter_p);
 494             interpreter_p = xstrdup (INTERP_TUI);
 495 #else
 496             fprintf_unfiltered (gdb_stderr,
 497                                 _("%s: TUI mode is not supported\n"),
 498                                 argv[0]);
 499             exit (1);
 500 #endif
 501             break;
 502           case OPT_WINDOWS:
 503             /* FIXME: cagney/2003-03-01: Not sure if this option is
 504                actually useful, and if it is, what it should do.  */
 505 #ifdef GDBTK
 506             /* --windows is equivalent to -i=insight.  */
 507             xfree (interpreter_p);
 508             interpreter_p = xstrdup (INTERP_INSIGHT);
 509 #endif
 510             use_windows = 1;
 511             break;
 512           case OPT_NOWINDOWS:
 513             /* -nw is equivalent to -i=console.  */
 514             xfree (interpreter_p);
 515             interpreter_p = xstrdup (INTERP_CONSOLE);
 516             use_windows = 0;
 517             break;
 518           case 'f':
 519             annotation_level = 1;
 520             /* We have probably been invoked from emacs.  Disable
 521                window interface.  */
 522             use_windows = 0;
 523             break;
 524           case 's':
 525             symarg = optarg;
 526             break;
 527           case 'e':
 528             execarg = optarg;
 529             break;
 530           case 'c':
 531             corearg = optarg;
 532             break;
 533           case 'p':
 534             pidarg = optarg;
 535             break;
 536           case 'x':
 537             cmdarg[ncmd].type = CMDARG_FILE;
 538             cmdarg[ncmd++].string = optarg;
 539             if (ncmd >= cmdsize)
 540               {
 541                 cmdsize *= 2;
 542                 cmdarg = xrealloc ((char *) cmdarg,
 543                                    cmdsize * sizeof (*cmdarg));
 544               }
 545             break;
 546           case 'X':
 547             cmdarg[ncmd].type = CMDARG_COMMAND;
 548             cmdarg[ncmd++].string = optarg;
 549             if (ncmd >= cmdsize)
 550               {
 551                 cmdsize *= 2;
 552                 cmdarg = xrealloc ((char *) cmdarg,
 553                                    cmdsize * sizeof (*cmdarg));
 554               }
 555             break;
 556           case 'B':
 557             batch_flag = batch_silent = 1;
 558             gdb_stdout = ui_file_new();
 559             break;
 560           case 'D':
 561             xfree (gdb_datadir);
 562             gdb_datadir = xstrdup (optarg);
 563             break;
 564 #ifdef GDBTK
 565           case 'z':
 566             {
 567               extern int gdbtk_test (char *);
 568
 569               if (!gdbtk_test (optarg))
 570                 {
 571                   fprintf_unfiltered (gdb_stderr,
 572                                       _("%s: unable to load "
 573                                         "tclcommand file \"%s\""),
 574                                       argv[0], optarg);
 575                   exit (1);
 576                 }
 577               break;
 578             }
 579           case 'y':
 580             /* Backwards compatibility only.  */
 581             break;
 582           case 'w':
 583             {
 584               /* Set the external editor commands when gdb is farming out files
 585                  to be edited by another program.  */
 586               extern char *external_editor_command;
 587
 588               external_editor_command = xstrdup (optarg);
 589               break;
 590             }
 591 #endif /* GDBTK */
 592           case 'i':
 593             xfree (interpreter_p);
 594             interpreter_p = xstrdup (optarg);
 595             break;
 596           case 'd':
 597             dirarg[ndir++] = optarg;
 598             if (ndir >= dirsize)
 599               {
 600                 dirsize *= 2;
 601                 dirarg = (char **) xrealloc ((char *) dirarg,
 602                                              dirsize * sizeof (*dirarg));
 603               }
 604             break;
 605           case 't':
 606             ttyarg = optarg;
 607             break;
 608           case 'q':
 609             quiet = 1;
 610             break;
 611           case 'b':
 612             {
 613               int i;
 614               char *p;
 615
 616               i = strtol (optarg, &p, 0);
 617               if (i == 0 && p == optarg)
 618
 619                 /* Don't use *_filtered or warning() (which relies on
 620                    current_target) until after initialize_all_files().  */
 621
 622                 fprintf_unfiltered
 623                   (gdb_stderr,
 624                    _("warning: could not set baud rate to `%s'.\n"), optarg);
 625               else
 626                 baud_rate = i;
 627             }
 628             break;
 629           case 'l':
 630             {
 631               int i;
 632               char *p;
 633
 634               i = strtol (optarg, &p, 0);
 635               if (i == 0 && p == optarg)
 636
 637                 /* Don't use *_filtered or warning() (which relies on
 638                    current_target) until after initialize_all_files().  */
 639
 640                 fprintf_unfiltered (gdb_stderr,
 641                                     _("warning: could not set "
 642                                       "timeout limit to `%s'.\n"), optarg);
 643               else
 644                 remote_timeout = i;
 645             }
 646             break;
 647
 648           case '?':
 649             fprintf_unfiltered (gdb_stderr,
 650                                 _("Use `%s --help' for a "
 651                                   "complete list of options.\n"),
 652                                 argv[0]);
 653             exit (1);
 654           }
 655       }
 656
 657     /* If --help or --version, disable window interface.  */
 658     if (print_help || print_version)
 659       {
 660         use_windows = 0;
 661       }
 662
 663     if (batch_flag)
 664       quiet = 1;
 665   }
 666
 667   /* Initialize all files.  Give the interpreter a chance to take
 668      control of the console via the deprecated_init_ui_hook ().  */
 669   gdb_init (argv[0]);
 670
 671   /* Now that gdb_init has created the initial inferior, we're in
 672      position to set args for that inferior.  */
 673   if (set_args)
 674     {
 675       /* The remaining options are the command-line options for the
 676          inferior.  The first one is the sym/exec file, and the rest
 677          are arguments.  */
 678       if (optind >= argc)
 679         {
 680           fprintf_unfiltered (gdb_stderr,
 681                               _("%s: `--args' specified but "
 682                                 "no program specified\n"),
 683                               argv[0]);
 684           exit (1);
 685         }
 686       symarg = argv[optind];
 687       execarg = argv[optind];
 688       ++optind;
 689       set_inferior_args_vector (argc - optind, &argv[optind]);
 690     }
 691   else
 692     {
 693       /* OK, that's all the options.  */
 694
 695       /* The first argument, if specified, is the name of the
 696          executable.  */
 697       if (optind < argc)
 698         {
 699           symarg = argv[optind];
 700           execarg = argv[optind];
 701           optind++;
 702         }
 703
 704       /* If the user hasn't already specified a PID or the name of a
 705          core file, then a second optional argument is allowed.  If
 706          present, this argument should be interpreted as either a
 707          PID or a core file, whichever works.  */
 708       if (pidarg == NULL && corearg == NULL && optind < argc)
 709         {
 710           pid_or_core_arg = argv[optind];
 711           optind++;
 712         }
 713
 714       /* Any argument left on the command line is unexpected and
 715          will be ignored.  Inform the user.  */
 716       if (optind < argc)
 717         fprintf_unfiltered (gdb_stderr,
 718                             _("Excess command line "
 719                               "arguments ignored. (%s%s)\n"),
 720                             argv[optind],
 721                             (optind == argc - 1) ? "" : " ...");
 722     }
 723
 724   /* Lookup gdbinit files.  Note that the gdbinit file name may be
 725      overriden during file initialization, so get_init_files should be
 726      called after gdb_init.  */
 727   get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
 728
 729   /* Do these (and anything which might call wrap_here or *_filtered)
 730      after initialize_all_files() but before the interpreter has been
 731      installed.  Otherwize the help/version messages will be eaten by
 732      the interpreter's output handler.  */
 733
 734   if (print_version)
 735     {
 736       print_gdb_version (gdb_stdout);
 737       wrap_here ("");
 738       printf_filtered ("\n");
 739       exit (0);
 740     }
 741
 742   if (print_help)
 743     {
 744       print_gdb_help (gdb_stdout);
 745       fputs_unfiltered ("\n", gdb_stdout);
 746       exit (0);
 747     }
 748
 749   /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
 750      GDB retain the old MI1 interpreter startup behavior.  Output the
 751      copyright message before the interpreter is installed.  That way
 752      it isn't encapsulated in MI output.  */
 753   if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
 754     {
 755       /* Print all the junk at the top, with trailing "..." if we are
 756          about to read a symbol file (possibly slowly).  */
 757       print_gdb_version (gdb_stdout);
 758       if (symarg)
 759         printf_filtered ("..");
 760       wrap_here ("");
 761       printf_filtered ("\n");
 762       gdb_flush (gdb_stdout);   /* Force to screen during slow
 763                                    operations.  */
 764     }
 765
 766   /* Install the default UI.  All the interpreters should have had a
 767      look at things by now.  Initialize the default interpreter.  */
 768
 769   {
 770     /* Find it.  */
 771     struct interp *interp = interp_lookup (interpreter_p);
 772
 773     if (interp == NULL)
 774       error (_("Interpreter `%s' unrecognized"), interpreter_p);
 775     /* Install it.  */
 776     if (!interp_set (interp, 1))
 777       {
 778         fprintf_unfiltered (gdb_stderr,
 779                             "Interpreter `%s' failed to initialize.\n",
 780                             interpreter_p);
 781         exit (1);
 782       }
 783   }
 784
 785   /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
 786      GDB retain the old MI1 interpreter startup behavior.  Output the
 787      copyright message after the interpreter is installed when it is
 788      any sane interpreter.  */
 789   if (!quiet && !current_interp_named_p (INTERP_MI1))
 790     {
 791       /* Print all the junk at the top, with trailing "..." if we are
 792          about to read a symbol file (possibly slowly).  */
 793       print_gdb_version (gdb_stdout);
 794       if (symarg)
 795         printf_filtered ("..");
 796       wrap_here ("");
 797       printf_filtered ("\n");
 798       gdb_flush (gdb_stdout);   /* Force to screen during slow
 799                                    operations.  */
 800     }
 801
 802   /* Set off error and warning messages with a blank line.  */
 803   error_pre_print = "\n";
 804   quit_pre_print = error_pre_print;
 805   warning_pre_print = _("\nwarning: ");
 806
 807   /* Read and execute the system-wide gdbinit file, if it exists.
 808      This is done *before* all the command line arguments are
 809      processed; it sets global parameters, which are independent of
 810      what file you are debugging or what directory you are in.  */
 811   if (system_gdbinit && !inhibit_gdbinit)
 812     catch_command_errors (source_script, system_gdbinit, 0, RETURN_MASK_ALL);
 813
 814   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
 815      *before* all the command line arguments are processed; it sets
 816      global parameters, which are independent of what file you are
 817      debugging or what directory you are in.  */
 818
 819   if (home_gdbinit && !inhibit_gdbinit)
 820     catch_command_errors (source_script, home_gdbinit, 0, RETURN_MASK_ALL);
 821
 822   /* Now perform all the actions indicated by the arguments.  */
 823   if (cdarg != NULL)
 824     {
 825       catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
 826     }
 827
 828   for (i = 0; i < ndir; i++)
 829     catch_command_errors (directory_switch, dirarg[i], 0, RETURN_MASK_ALL);
 830   xfree (dirarg);
 831
 832   /* Skip auto-loading section-specified scripts until we've sourced
 833      local_gdbinit (which is often used to augment the source search
 834      path).  */
 835   save_auto_load = gdbpy_global_auto_load;
 836   gdbpy_global_auto_load = 0;
 837
 838   if (execarg != NULL
 839       && symarg != NULL
 840       && strcmp (execarg, symarg) == 0)
 841     {
 842       /* The exec file and the symbol-file are the same.  If we can't
 843          open it, better only print one error message.
 844          catch_command_errors returns non-zero on success!  */
 845       if (catch_command_errors (exec_file_attach, execarg,
 846                                 !batch_flag, RETURN_MASK_ALL))
 847         catch_command_errors (symbol_file_add_main, symarg,
 848                               !batch_flag, RETURN_MASK_ALL);
 849     }
 850   else
 851     {
 852       if (execarg != NULL)
 853         catch_command_errors (exec_file_attach, execarg,
 854                               !batch_flag, RETURN_MASK_ALL);
 855       if (symarg != NULL)
 856         catch_command_errors (symbol_file_add_main, symarg,
 857                               !batch_flag, RETURN_MASK_ALL);
 858     }
 859
 860   if (corearg && pidarg)
 861     error (_("Can't attach to process and specify "
 862              "a core file at the same time."));
 863
 864   if (corearg != NULL)
 865     catch_command_errors (core_file_command, corearg,
 866                           !batch_flag, RETURN_MASK_ALL);
 867   else if (pidarg != NULL)
 868     catch_command_errors (attach_command, pidarg,
 869                           !batch_flag, RETURN_MASK_ALL);
 870   else if (pid_or_core_arg)
 871     {
 872       /* The user specified 'gdb program pid' or gdb program core'.
 873          If pid_or_core_arg's first character is a digit, try attach
 874          first and then corefile.  Otherwise try just corefile.  */
 875
 876       if (isdigit (pid_or_core_arg[0]))
 877         {
 878           if (catch_command_errors (attach_command, pid_or_core_arg,
 879                                     !batch_flag, RETURN_MASK_ALL) == 0)
 880             catch_command_errors (core_file_command, pid_or_core_arg,
 881                                   !batch_flag, RETURN_MASK_ALL);
 882         }
 883       else /* Can't be a pid, better be a corefile.  */
 884         catch_command_errors (core_file_command, pid_or_core_arg,
 885                               !batch_flag, RETURN_MASK_ALL);
 886     }
 887
 888   if (ttyarg != NULL)
 889     set_inferior_io_terminal (ttyarg);
 890
 891   /* Error messages should no longer be distinguished with extra output.  */
 892   error_pre_print = NULL;
 893   quit_pre_print = NULL;
 894   warning_pre_print = _("warning: ");
 895
 896   /* Read the .gdbinit file in the current directory, *if* it isn't
 897      the same as the $HOME/.gdbinit file (it should exist, also).  */
 898   if (local_gdbinit && !inhibit_gdbinit)
 899     catch_command_errors (source_script, local_gdbinit, 0, RETURN_MASK_ALL);
 900
 901   /* Now that all .gdbinit's have been read and all -d options have been
 902      processed, we can read any scripts mentioned in SYMARG.
 903      We wait until now because it is common to add to the source search
 904      path in local_gdbinit.  */
 905   gdbpy_global_auto_load = save_auto_load;
 906   ALL_OBJFILES (objfile)
 907     load_auto_scripts_for_objfile (objfile);
 908
 909   for (i = 0; i < ncmd; i++)
 910     {
 911       if (cmdarg[i].type == CMDARG_FILE)
 912         catch_command_errors (source_script, cmdarg[i].string,
 913                               !batch_flag, RETURN_MASK_ALL);
 914       else  /* cmdarg[i].type == CMDARG_COMMAND */
 915         catch_command_errors (execute_command, cmdarg[i].string,
 916                               !batch_flag, RETURN_MASK_ALL);
 917     }
 918   xfree (cmdarg);
 919
 920   /* Read in the old history after all the command files have been
 921      read.  */
 922   init_history ();
 923
 924   if (batch_flag)
 925     {
 926       /* We have hit the end of the batch file.  */
 927       quit_force (NULL, 0);
 928     }
 929
 930   /* Show time and/or space usage.  */
 931   do_cleanups (pre_stat_chain);
 932
 933   /* NOTE: cagney/1999-11-07: There is probably no reason for not
 934      moving this loop and the code found in captured_command_loop()
 935      into the command_loop() proper.  The main thing holding back that
 936      change - SET_TOP_LEVEL() - has been eliminated.  */
 937   while (1)
 938     {
 939       catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
 940     }
 941   /* No exit -- exit is through quit_command.  */
 942 }
 943
 944 int
 945 gdb_main (struct captured_main_args *args)
 946 {
 947   use_windows = args->use_windows;
 948   catch_errors (captured_main, args, "", RETURN_MASK_ALL);
 949   /* The only way to end up here is by an error (normal exit is
 950      handled by quit_force()), hence always return an error status.  */
 951   return 1;
 952 }
 953
 954
 955 /* Don't use *_filtered for printing help.  We don't want to prompt
 956    for continue no matter how small the screen or how much we're going
 957    to print.  */
 958
 959 static void
 960 print_gdb_help (struct ui_file *stream)
 961 {
 962   char *system_gdbinit;
 963   char *home_gdbinit;
 964   char *local_gdbinit;
 965
 966   get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
 967
 968   fputs_unfiltered (_("\
 969 This is the GNU debugger.  Usage:\n\n\
 970     gdb [options] [executable-file [core-file or process-id]]\n\
 971     gdb [options] --args executable-file [inferior-arguments ...]\n\n\
 972 Options:\n\n\
 973 "), stream);
 974   fputs_unfiltered (_("\
 975   --args             Arguments after executable-file are passed to inferior\n\
 976 "), stream);
 977   fputs_unfiltered (_("\
 978   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
 979   --batch            Exit after processing options.\n\
 980   --batch-silent     As for --batch, but suppress all gdb stdout output.\n\
 981   --return-child-result\n\
 982                      GDB exit code will be the child's exit code.\n\
 983   --cd=DIR           Change current directory to DIR.\n\
 984   --command=FILE, -x Execute GDB commands from FILE.\n\
 985   --eval-command=COMMAND, -ex\n\
 986                      Execute a single GDB command.\n\
 987                      May be used multiple times and in conjunction\n\
 988                      with --command.\n\
 989   --core=COREFILE    Analyze the core dump COREFILE.\n\
 990   --pid=PID          Attach to running process PID.\n\
 991 "), stream);
 992   fputs_unfiltered (_("\
 993   --dbx              DBX compatibility mode.\n\
 994   --directory=DIR    Search for source files in DIR.\n\
 995   --epoch            Output information used by epoch emacs-GDB interface.\n\
 996   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 997   --fullname         Output information used by emacs-GDB interface.\n\
 998   --help             Print this message.\n\
 999 "), stream);
1000   fputs_unfiltered (_("\
1001   --interpreter=INTERP\n\
1002                      Select a specific interpreter / user interface\n\
1003 "), stream);
1004   fputs_unfiltered (_("\
1005   -l TIMEOUT         Set timeout in seconds for remote debugging.\n\
1006   --nw               Do not use a window interface.\n\
1007   --nx               Do not read "), stream);
1008   fputs_unfiltered (gdbinit, stream);
1009   fputs_unfiltered (_(" file.\n\
1010   --quiet            Do not print version number on startup.\n\
1011   --readnow          Fully read symbol files on first access.\n\
1012 "), stream);
1013   fputs_unfiltered (_("\
1014   --se=FILE          Use FILE as symbol file and executable file.\n\
1015   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
1016   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
1017 "), stream);
1018 #if defined(TUI)
1019   fputs_unfiltered (_("\
1020   --tui              Use a terminal user interface.\n\
1021 "), stream);
1022 #endif
1023   fputs_unfiltered (_("\
1024   --version          Print version information and then exit.\n\
1025   -w                 Use a window interface.\n\
1026   --write            Set writing into executable and core files.\n\
1027   --xdb              XDB compatibility mode.\n\
1028 "), stream);
1029   fputs_unfiltered (_("\n\
1030 At startup, GDB reads the following init files and executes their commands:\n\
1031 "), stream);
1032   if (system_gdbinit)
1033     fprintf_unfiltered (stream, _("\
1034    * system-wide init file: %s\n\
1035 "), system_gdbinit);
1036   if (home_gdbinit)
1037     fprintf_unfiltered (stream, _("\
1038    * user-specific init file: %s\n\
1039 "), home_gdbinit);
1040   if (local_gdbinit)
1041     fprintf_unfiltered (stream, _("\
1042    * local init file: ./%s\n\
1043 "), local_gdbinit);
1044   fputs_unfiltered (_("\n\
1045 For more information, type \"help\" from within GDB, or consult the\n\
1046 GDB manual (available as on-line info or a printed manual).\n\
1047 "), stream);
1048   if (REPORT_BUGS_TO[0] && stream == gdb_stdout)
1049     fprintf_unfiltered (stream, _("\
1050 Report bugs to \"%s\".\n\
1051 "), REPORT_BUGS_TO);
1052 }