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