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