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