gdb/main.c

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