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