gdb/main.c

   1 /* Top level stuff for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
   3    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "top.h"
  25 #include "target.h"
  26 #include "inferior.h"
  27 #include "symfile.h"
  28 #include "gdbcore.h"
  29
  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 "main.h"
  41
  42 /* If nonzero, display time usage both at startup and for each command.  */
  43
  44 int display_time;
  45
  46 /* If nonzero, display space usage both at startup and for each command.  */
  47
  48 int display_space;
  49
  50 /* Whether this is the async version or not.  The async version is
  51    invoked on the command line with the -nw --async options.  In this
  52    version, the usual command_loop is substituted by and event loop which
  53    processes UI events asynchronously. */
  54 int event_loop_p = 1;
  55
  56 /* Has an interpreter been specified and if so, which. */
  57 char *interpreter_p;
  58
  59 /* Whether this is the command line version or not */
  60 int tui_version = 0;
  61
  62 /* Whether xdb commands will be handled */
  63 int xdb_commands = 0;
  64
  65 /* Whether dbx commands will be handled */
  66 int dbx_commands = 0;
  67
  68 /* System root path, used to find libraries etc.  */
  69 char *gdb_sysroot = 0;
  70
  71 struct ui_file *gdb_stdout;
  72 struct ui_file *gdb_stderr;
  73 struct ui_file *gdb_stdlog;
  74 struct ui_file *gdb_stdtarg;
  75
  76 /* Used to initialize error() - defined in utils.c */
  77
  78 extern void error_init (void);
  79
  80 /* Whether to enable writing into executable and core files */
  81 extern int write_files;
  82
  83 static void print_gdb_help (struct ui_file *);
  84
  85 /* These two are used to set the external editor commands when gdb is farming
  86    out files to be edited by another program. */
  87
  88 extern char *external_editor_command;
  89
  90 /* Call command_loop.  If it happens to return, pass that through as a
  91    non-zero return status. */
  92
  93 static int
  94 captured_command_loop (void *data)
  95 {
  96   if (command_loop_hook == NULL)
  97     command_loop ();
  98   else
  99     command_loop_hook ();
 100   /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
 101      would clean things up (restoring the cleanup chain) to the state
 102      they were just prior to the call.  Technically, this means that
 103      the do_cleanups() below is redundant.  Unfortunately, many FUNCs
 104      are not that well behaved.  do_cleanups should either be replaced
 105      with a do_cleanups call (to cover the problem) or an assertion
 106      check to detect bad FUNCs code. */
 107   do_cleanups (ALL_CLEANUPS);
 108   /* If the command_loop returned, normally (rather than threw an
 109      error) we try to quit. If the quit is aborted, catch_errors()
 110      which called this catch the signal and restart the command
 111      loop. */
 112   quit_command (NULL, instream == stdin);
 113   return 1;
 114 }
 115
 116 static int
 117 captured_main (void *data)
 118 {
 119   struct captured_main_args *context = data;
 120   int argc = context->argc;
 121   char **argv = context->argv;
 122   int count;
 123   static int quiet = 0;
 124   static int batch = 0;
 125   static int set_args = 0;
 126
 127   /* Pointers to various arguments from command line.  */
 128   char *symarg = NULL;
 129   char *execarg = NULL;
 130   char *corearg = NULL;
 131   char *cdarg = NULL;
 132   char *ttyarg = NULL;
 133
 134   /* These are static so that we can take their address in an initializer.  */
 135   static int print_help;
 136   static int print_version;
 137
 138   /* Pointers to all arguments of --command option.  */
 139   char **cmdarg;
 140   /* Allocated size of cmdarg.  */
 141   int cmdsize;
 142   /* Number of elements of cmdarg used.  */
 143   int ncmd;
 144
 145   /* Indices of all arguments of --directory option.  */
 146   char **dirarg;
 147   /* Allocated size.  */
 148   int dirsize;
 149   /* Number of elements used.  */
 150   int ndir;
 151
 152   struct stat homebuf, cwdbuf;
 153   char *homedir, *homeinit;
 154
 155   register int i;
 156
 157   long time_at_startup = get_run_time ();
 158
 159 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 160   setlocale (LC_MESSAGES, "");
 161 #endif
 162 #if defined (HAVE_SETLOCALE)
 163   setlocale (LC_CTYPE, "");
 164 #endif
 165   bindtextdomain (PACKAGE, LOCALEDIR);
 166   textdomain (PACKAGE);
 167
 168   START_PROGRESS (argv[0], 0);
 169
 170 #ifdef MPW
 171   /* Do all Mac-specific setup. */
 172   mac_init ();
 173 #endif /* MPW */
 174
 175   /* This needs to happen before the first use of malloc.  */
 176   init_malloc (NULL);
 177
 178 #if defined (ALIGN_STACK_ON_STARTUP)
 179   i = (int) &count & 0x3;
 180   if (i != 0)
 181     alloca (4 - i);
 182 #endif
 183
 184   cmdsize = 1;
 185   cmdarg = (char **) xmalloc (cmdsize * sizeof (*cmdarg));
 186   ncmd = 0;
 187   dirsize = 1;
 188   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
 189   ndir = 0;
 190
 191   quit_flag = 0;
 192   line = (char *) xmalloc (linesize);
 193   line[0] = '\0';               /* Terminate saved (now empty) cmd line */
 194   instream = stdin;
 195
 196   getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 197   current_directory = gdb_dirbuf;
 198
 199   gdb_stdout = stdio_fileopen (stdout);
 200   gdb_stderr = stdio_fileopen (stderr);
 201   gdb_stdlog = gdb_stderr;      /* for moment */
 202   gdb_stdtarg = gdb_stderr;     /* for moment */
 203
 204   /* initialize error() */
 205   error_init ();
 206
 207   /* Set the sysroot path.  */
 208 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
 209   gdb_sysroot = make_relative_prefix (argv[0], BINDIR, TARGET_SYSTEM_ROOT);
 210   if (gdb_sysroot)
 211     {
 212       struct stat s;
 213       int res = 0;
 214
 215       if (stat (gdb_sysroot, &s) == 0)
 216         if (S_ISDIR (s.st_mode))
 217           res = 1;
 218
 219       if (res == 0)
 220         {
 221           xfree (gdb_sysroot);
 222           gdb_sysroot = TARGET_SYSTEM_ROOT;
 223         }
 224     }
 225   else
 226     gdb_sysroot = TARGET_SYSTEM_ROOT;
 227 #else
 228 #if defined (TARGET_SYSTEM_ROOT)
 229   gdb_sysroot = TARGET_SYSTEM_ROOT;
 230 #else
 231   gdb_sysroot = "";
 232 #endif
 233 #endif
 234
 235   /* Parse arguments and options.  */
 236   {
 237     int c;
 238     /* When var field is 0, use flag field to record the equivalent
 239        short option (or arbitrary numbers starting at 10 for those
 240        with no equivalent).  */
 241     static struct option long_options[] =
 242     {
 243       {"async", no_argument, &event_loop_p, 1},
 244       {"noasync", no_argument, &event_loop_p, 0},
 245 #if defined(TUI)
 246       {"tui", no_argument, &tui_version, 1},
 247 #endif
 248       {"xdb", no_argument, &xdb_commands, 1},
 249       {"dbx", no_argument, &dbx_commands, 1},
 250       {"readnow", no_argument, &readnow_symbol_files, 1},
 251       {"r", no_argument, &readnow_symbol_files, 1},
 252       {"mapped", no_argument, &mapped_symbol_files, 1},
 253       {"m", no_argument, &mapped_symbol_files, 1},
 254       {"quiet", no_argument, &quiet, 1},
 255       {"q", no_argument, &quiet, 1},
 256       {"silent", no_argument, &quiet, 1},
 257       {"nx", no_argument, &inhibit_gdbinit, 1},
 258       {"n", no_argument, &inhibit_gdbinit, 1},
 259       {"batch", no_argument, &batch, 1},
 260       {"epoch", no_argument, &epoch_interface, 1},
 261
 262     /* This is a synonym for "--annotate=1".  --annotate is now preferred,
 263        but keep this here for a long time because people will be running
 264        emacses which use --fullname.  */
 265       {"fullname", no_argument, 0, 'f'},
 266       {"f", no_argument, 0, 'f'},
 267
 268       {"annotate", required_argument, 0, 12},
 269       {"help", no_argument, &print_help, 1},
 270       {"se", required_argument, 0, 10},
 271       {"symbols", required_argument, 0, 's'},
 272       {"s", required_argument, 0, 's'},
 273       {"exec", required_argument, 0, 'e'},
 274       {"e", required_argument, 0, 'e'},
 275       {"core", required_argument, 0, 'c'},
 276       {"c", required_argument, 0, 'c'},
 277       {"pid", required_argument, 0, 'p'},
 278       {"p", required_argument, 0, 'p'},
 279       {"command", required_argument, 0, 'x'},
 280       {"version", no_argument, &print_version, 1},
 281       {"x", required_argument, 0, 'x'},
 282 #ifdef GDBTK
 283       {"tclcommand", required_argument, 0, 'z'},
 284       {"enable-external-editor", no_argument, 0, 'y'},
 285       {"editor-command", required_argument, 0, 'w'},
 286 #endif
 287       {"ui", required_argument, 0, 'i'},
 288       {"interpreter", required_argument, 0, 'i'},
 289       {"i", required_argument, 0, 'i'},
 290       {"directory", required_argument, 0, 'd'},
 291       {"d", required_argument, 0, 'd'},
 292       {"cd", required_argument, 0, 11},
 293       {"tty", required_argument, 0, 't'},
 294       {"baud", required_argument, 0, 'b'},
 295       {"b", required_argument, 0, 'b'},
 296       {"nw", no_argument, &use_windows, 0},
 297       {"nowindows", no_argument, &use_windows, 0},
 298       {"w", no_argument, &use_windows, 1},
 299       {"windows", no_argument, &use_windows, 1},
 300       {"statistics", no_argument, 0, 13},
 301       {"write", no_argument, &write_files, 1},
 302       {"args", no_argument, &set_args, 1},
 303 /* Allow machine descriptions to add more options... */
 304 #ifdef ADDITIONAL_OPTIONS
 305       ADDITIONAL_OPTIONS
 306 #endif
 307       {0, no_argument, 0, 0}
 308     };
 309
 310     while (1)
 311       {
 312         int option_index;
 313
 314         c = getopt_long_only (argc, argv, "",
 315                               long_options, &option_index);
 316         if (c == EOF || set_args)
 317           break;
 318
 319         /* Long option that takes an argument.  */
 320         if (c == 0 && long_options[option_index].flag == 0)
 321           c = long_options[option_index].val;
 322
 323         switch (c)
 324           {
 325           case 0:
 326             /* Long option that just sets a flag.  */
 327             break;
 328           case 10:
 329             symarg = optarg;
 330             execarg = optarg;
 331             break;
 332           case 11:
 333             cdarg = optarg;
 334             break;
 335           case 12:
 336             /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
 337             annotation_level = atoi (optarg);
 338             break;
 339           case 13:
 340             /* Enable the display of both time and space usage.  */
 341             display_time = 1;
 342             display_space = 1;
 343             break;
 344           case 'f':
 345             annotation_level = 1;
 346 /* We have probably been invoked from emacs.  Disable window interface.  */
 347             use_windows = 0;
 348             break;
 349           case 's':
 350             symarg = optarg;
 351             break;
 352           case 'e':
 353             execarg = optarg;
 354             break;
 355           case 'c':
 356             corearg = optarg;
 357             break;
 358           case 'p':
 359             /* "corearg" is shared by "--core" and "--pid" */
 360             corearg = optarg;
 361             break;
 362           case 'x':
 363             cmdarg[ncmd++] = optarg;
 364             if (ncmd >= cmdsize)
 365               {
 366                 cmdsize *= 2;
 367                 cmdarg = (char **) xrealloc ((char *) cmdarg,
 368                                              cmdsize * sizeof (*cmdarg));
 369               }
 370             break;
 371 #ifdef GDBTK
 372           case 'z':
 373             {
 374 extern int gdbtk_test (char *);
 375               if (!gdbtk_test (optarg))
 376                 {
 377                   fprintf_unfiltered (gdb_stderr, _("%s: unable to load tclcommand file \"%s\""),
 378                                       argv[0], optarg);
 379                   exit (1);
 380                 }
 381               break;
 382             }
 383           case 'y':
 384             /* Backwards compatibility only.  */
 385             break;
 386           case 'w':
 387             {
 388               external_editor_command = xstrdup (optarg);
 389               break;
 390             }
 391 #endif /* GDBTK */
 392           case 'i':
 393             interpreter_p = optarg;
 394             break;
 395           case 'd':
 396             dirarg[ndir++] = optarg;
 397             if (ndir >= dirsize)
 398               {
 399                 dirsize *= 2;
 400                 dirarg = (char **) xrealloc ((char *) dirarg,
 401                                              dirsize * sizeof (*dirarg));
 402               }
 403             break;
 404           case 't':
 405             ttyarg = optarg;
 406             break;
 407           case 'q':
 408             quiet = 1;
 409             break;
 410           case 'b':
 411             {
 412               int i;
 413               char *p;
 414
 415               i = strtol (optarg, &p, 0);
 416               if (i == 0 && p == optarg)
 417
 418                 /* Don't use *_filtered or warning() (which relies on
 419                    current_target) until after initialize_all_files(). */
 420
 421                 fprintf_unfiltered
 422                   (gdb_stderr,
 423                    _("warning: could not set baud rate to `%s'.\n"), optarg);
 424               else
 425                 baud_rate = i;
 426             }
 427             break;
 428           case 'l':
 429             {
 430               int i;
 431               char *p;
 432
 433               i = strtol (optarg, &p, 0);
 434               if (i == 0 && p == optarg)
 435
 436                 /* Don't use *_filtered or warning() (which relies on
 437                    current_target) until after initialize_all_files(). */
 438
 439                 fprintf_unfiltered
 440                   (gdb_stderr,
 441                  _("warning: could not set timeout limit to `%s'.\n"), optarg);
 442               else
 443                 remote_timeout = i;
 444             }
 445             break;
 446
 447 #ifdef ADDITIONAL_OPTION_CASES
 448             ADDITIONAL_OPTION_CASES
 449 #endif
 450           case '?':
 451             fprintf_unfiltered (gdb_stderr,
 452                         _("Use `%s --help' for a complete list of options.\n"),
 453                                 argv[0]);
 454             exit (1);
 455           }
 456       }
 457
 458     /* If --help or --version, disable window interface.  */
 459     if (print_help || print_version)
 460       {
 461         use_windows = 0;
 462 #ifdef TUI
 463         /* Disable the TUI as well.  */
 464         tui_version = 0;
 465 #endif
 466       }
 467
 468 #ifdef TUI
 469     /* An explicit --tui flag overrides the default UI, which is the
 470        window system.  */
 471     if (tui_version)
 472       use_windows = 0;
 473 #endif
 474
 475     if (set_args)
 476       {
 477         /* The remaining options are the command-line options for the
 478            inferior.  The first one is the sym/exec file, and the rest
 479            are arguments.  */
 480         if (optind >= argc)
 481           {
 482             fprintf_unfiltered (gdb_stderr,
 483                                 _("%s: `--args' specified but no program specified\n"),
 484                                 argv[0]);
 485             exit (1);
 486           }
 487         symarg = argv[optind];
 488         execarg = argv[optind];
 489         ++optind;
 490         set_inferior_args_vector (argc - optind, &argv[optind]);
 491       }
 492     else
 493       {
 494         /* OK, that's all the options.  The other arguments are filenames.  */
 495         count = 0;
 496         for (; optind < argc; optind++)
 497           switch (++count)
 498             {
 499             case 1:
 500               symarg = argv[optind];
 501               execarg = argv[optind];
 502               break;
 503             case 2:
 504               /* The documentation says this can be a "ProcID" as well.
 505                  We will try it as both a corefile and a pid.  */
 506               corearg = argv[optind];
 507               break;
 508             case 3:
 509               fprintf_unfiltered (gdb_stderr,
 510                                   _("Excess command line arguments ignored. (%s%s)\n"),
 511                                   argv[optind], (optind == argc - 1) ? "" : " ...");
 512               break;
 513             }
 514       }
 515     if (batch)
 516       quiet = 1;
 517   }
 518
 519   /* Initialize all files.  Give the interpreter a chance to take
 520      control of the console via the init_ui_hook()) */
 521   gdb_init (argv[0]);
 522
 523   /* Do these (and anything which might call wrap_here or *_filtered)
 524      after initialize_all_files.  */
 525   if (print_version)
 526     {
 527       print_gdb_version (gdb_stdout);
 528       wrap_here ("");
 529       printf_filtered ("\n");
 530       exit (0);
 531     }
 532
 533   if (print_help)
 534     {
 535       print_gdb_help (gdb_stdout);
 536       fputs_unfiltered ("\n", gdb_stdout);
 537       exit (0);
 538     }
 539
 540   if (!quiet)
 541     {
 542       /* Print all the junk at the top, with trailing "..." if we are about
 543          to read a symbol file (possibly slowly).  */
 544       print_gdb_version (gdb_stdout);
 545       if (symarg)
 546         printf_filtered ("..");
 547       wrap_here ("");
 548       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 549     }
 550
 551   error_pre_print = "\n\n";
 552   quit_pre_print = error_pre_print;
 553
 554   /* We may get more than one warning, don't double space all of them... */
 555   warning_pre_print = _("\nwarning: ");
 556
 557   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
 558      *before* all the command line arguments are processed; it sets
 559      global parameters, which are independent of what file you are
 560      debugging or what directory you are in.  */
 561   homedir = getenv ("HOME");
 562   if (homedir)
 563     {
 564       homeinit = (char *) alloca (strlen (homedir) +
 565                                   strlen (gdbinit) + 10);
 566       strcpy (homeinit, homedir);
 567       strcat (homeinit, "/");
 568       strcat (homeinit, gdbinit);
 569
 570       if (!inhibit_gdbinit)
 571         {
 572           catch_command_errors (source_command, homeinit, 0, RETURN_MASK_ALL);
 573         }
 574
 575       /* Do stats; no need to do them elsewhere since we'll only
 576          need them if homedir is set.  Make sure that they are
 577          zero in case one of them fails (this guarantees that they
 578          won't match if either exists).  */
 579
 580       memset (&homebuf, 0, sizeof (struct stat));
 581       memset (&cwdbuf, 0, sizeof (struct stat));
 582
 583       stat (homeinit, &homebuf);
 584       stat (gdbinit, &cwdbuf);  /* We'll only need this if
 585                                    homedir was set.  */
 586     }
 587
 588   /* Now perform all the actions indicated by the arguments.  */
 589   if (cdarg != NULL)
 590     {
 591       catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
 592     }
 593
 594   for (i = 0; i < ndir; i++)
 595     catch_command_errors (directory_command, dirarg[i], 0, RETURN_MASK_ALL);
 596   xfree (dirarg);
 597
 598   if (execarg != NULL
 599       && symarg != NULL
 600       && STREQ (execarg, symarg))
 601     {
 602       /* The exec file and the symbol-file are the same.  If we can't
 603          open it, better only print one error message.
 604          catch_command_errors returns non-zero on success! */
 605       if (catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL))
 606         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 607     }
 608   else
 609     {
 610       if (execarg != NULL)
 611         catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL);
 612       if (symarg != NULL)
 613         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 614     }
 615
 616   /* After the symbol file has been read, print a newline to get us
 617      beyond the copyright line...  But errors should still set off
 618      the error message with a (single) blank line.  */
 619   if (!quiet)
 620     printf_filtered ("\n");
 621   error_pre_print = "\n";
 622   quit_pre_print = error_pre_print;
 623   warning_pre_print = _("\nwarning: ");
 624
 625   if (corearg != NULL)
 626     {
 627       /* corearg may be either a corefile or a pid.
 628          If its first character is a digit, try attach first
 629          and then corefile.  Otherwise try corefile first. */
 630
 631       if (isdigit (corearg[0]))
 632         {
 633           if (catch_command_errors (attach_command, corearg,
 634                                     !batch, RETURN_MASK_ALL) == 0)
 635             catch_command_errors (core_file_command, corearg,
 636                                   !batch, RETURN_MASK_ALL);
 637         }
 638       else /* Can't be a pid, better be a corefile. */
 639         catch_command_errors (core_file_command, corearg,
 640                               !batch, RETURN_MASK_ALL);
 641     }
 642
 643   if (ttyarg != NULL)
 644     catch_command_errors (tty_command, ttyarg, !batch, RETURN_MASK_ALL);
 645
 646 #ifdef ADDITIONAL_OPTION_HANDLER
 647   ADDITIONAL_OPTION_HANDLER;
 648 #endif
 649
 650   /* Error messages should no longer be distinguished with extra output. */
 651   error_pre_print = NULL;
 652   quit_pre_print = NULL;
 653   warning_pre_print = _("warning: ");
 654
 655   /* Read the .gdbinit file in the current directory, *if* it isn't
 656      the same as the $HOME/.gdbinit file (it should exist, also).  */
 657
 658   if (!homedir
 659       || memcmp ((char *) &homebuf, (char *) &cwdbuf, sizeof (struct stat)))
 660     if (!inhibit_gdbinit)
 661       {
 662         catch_command_errors (source_command, gdbinit, 0, RETURN_MASK_ALL);
 663       }
 664
 665   for (i = 0; i < ncmd; i++)
 666     {
 667 #if 0
 668       /* NOTE: cagney/1999-11-03: SET_TOP_LEVEL() was a macro that
 669          expanded into a call to setjmp().  */
 670       if (!SET_TOP_LEVEL ()) /* NB: This is #if 0'd out */
 671         {
 672           /* NOTE: I am commenting this out, because it is not clear
 673              where this feature is used. It is very old and
 674              undocumented. ezannoni: 1999-05-04 */
 675 #if 0
 676           if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
 677             read_command_file (stdin);
 678           else
 679 #endif
 680             source_command (cmdarg[i], !batch);
 681           do_cleanups (ALL_CLEANUPS);
 682         }
 683 #endif
 684       catch_command_errors (source_command, cmdarg[i], !batch, RETURN_MASK_ALL);
 685     }
 686   xfree (cmdarg);
 687
 688   /* Read in the old history after all the command files have been read. */
 689   init_history ();
 690
 691   if (batch)
 692     {
 693       /* We have hit the end of the batch file.  */
 694       exit (0);
 695     }
 696
 697   /* Do any host- or target-specific hacks.  This is used for i960 targets
 698      to force the user to set a nindy target and spec its parameters.  */
 699
 700 #ifdef BEFORE_MAIN_LOOP_HOOK
 701   BEFORE_MAIN_LOOP_HOOK;
 702 #endif
 703
 704   END_PROGRESS (argv[0]);
 705
 706   /* Show time and/or space usage.  */
 707
 708   if (display_time)
 709     {
 710       long init_time = get_run_time () - time_at_startup;
 711
 712       printf_unfiltered (_("Startup time: %ld.%06ld\n"),
 713                          init_time / 1000000, init_time % 1000000);
 714     }
 715
 716   if (display_space)
 717     {
 718 #ifdef HAVE_SBRK
 719       extern char **environ;
 720       char *lim = (char *) sbrk (0);
 721
 722       printf_unfiltered (_("Startup size: data size %ld\n"),
 723                          (long) (lim - (char *) &environ));
 724 #endif
 725     }
 726
 727 #if 0
 728   /* FIXME: cagney/1999-11-06: The original main loop was like: */
 729   while (1)
 730     {
 731       if (!SET_TOP_LEVEL ())
 732         {
 733           do_cleanups (ALL_CLEANUPS);   /* Do complete cleanup */
 734           /* GUIs generally have their own command loop, mainloop, or whatever.
 735              This is a good place to gain control because many error
 736              conditions will end up here via longjmp(). */
 737           if (command_loop_hook)
 738             command_loop_hook ();
 739           else
 740             command_loop ();
 741           quit_command ((char *) 0, instream == stdin);
 742         }
 743     }
 744   /* NOTE: If the command_loop() returned normally, the loop would
 745      attempt to exit by calling the function quit_command().  That
 746      function would either call exit() or throw an error returning
 747      control to SET_TOP_LEVEL. */
 748   /* NOTE: The function do_cleanups() was called once each time round
 749      the loop.  The usefulness of the call isn't clear.  If an error
 750      was thrown, everything would have already been cleaned up.  If
 751      command_loop() returned normally and quit_command() was called,
 752      either exit() or error() (again cleaning up) would be called. */
 753 #endif
 754   /* NOTE: cagney/1999-11-07: There is probably no reason for not
 755      moving this loop and the code found in captured_command_loop()
 756      into the command_loop() proper.  The main thing holding back that
 757      change - SET_TOP_LEVEL() - has been eliminated. */
 758   while (1)
 759     {
 760       catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
 761     }
 762   /* No exit -- exit is through quit_command.  */
 763 }
 764
 765 int
 766 gdb_main (struct captured_main_args *args)
 767 {
 768   use_windows = args->use_windows;
 769   catch_errors (captured_main, args, "", RETURN_MASK_ALL);
 770   return 0;
 771 }
 772
 773
 774 /* Don't use *_filtered for printing help.  We don't want to prompt
 775    for continue no matter how small the screen or how much we're going
 776    to print.  */
 777
 778 static void
 779 print_gdb_help (struct ui_file *stream)
 780 {
 781   fputs_unfiltered (_("\
 782 This is the GNU debugger.  Usage:\n\n\
 783     gdb [options] [executable-file [core-file or process-id]]\n\
 784     gdb [options] --args executable-file [inferior-arguments ...]\n\n\
 785 Options:\n\n\
 786 "), stream);
 787   fputs_unfiltered (_("\
 788   --args             Arguments after executable-file are passed to inferior\n\
 789 "), stream);
 790   fputs_unfiltered (_("\
 791   --[no]async        Enable (disable) asynchronous version of CLI\n\
 792 "), stream);
 793   fputs_unfiltered (_("\
 794   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
 795   --batch            Exit after processing options.\n\
 796   --cd=DIR           Change current directory to DIR.\n\
 797   --command=FILE     Execute GDB commands from FILE.\n\
 798   --core=COREFILE    Analyze the core dump COREFILE.\n\
 799   --pid=PID          Attach to running process PID.\n\
 800 "), stream);
 801   fputs_unfiltered (_("\
 802   --dbx              DBX compatibility mode.\n\
 803   --directory=DIR    Search for source files in DIR.\n\
 804   --epoch            Output information used by epoch emacs-GDB interface.\n\
 805   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 806   --fullname         Output information used by emacs-GDB interface.\n\
 807   --help             Print this message.\n\
 808 "), stream);
 809   fputs_unfiltered (_("\
 810   --interpreter=INTERP\n\
 811                      Select a specific interpreter / user interface\n\
 812 "), stream);
 813   fputs_unfiltered (_("\
 814   --mapped           Use mapped symbol files if supported on this system.\n\
 815   --nw               Do not use a window interface.\n\
 816   --nx               Do not read "), stream);
 817   fputs_unfiltered (gdbinit, stream);
 818   fputs_unfiltered (_(" file.\n\
 819   --quiet            Do not print version number on startup.\n\
 820   --readnow          Fully read symbol files on first access.\n\
 821 "), stream);
 822   fputs_unfiltered (_("\
 823   --se=FILE          Use FILE as symbol file and executable file.\n\
 824   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
 825   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
 826 "), stream);
 827 #if defined(TUI)
 828   fputs_unfiltered (_("\
 829   --tui              Use a terminal user interface.\n\
 830 "), stream);
 831 #endif
 832   fputs_unfiltered (_("\
 833   --version          Print version information and then exit.\n\
 834   -w                 Use a window interface.\n\
 835   --write            Set writing into executable and core files.\n\
 836   --xdb              XDB compatibility mode.\n\
 837 "), stream);
 838 #ifdef ADDITIONAL_OPTION_HELP
 839   fputs_unfiltered (ADDITIONAL_OPTION_HELP, stream);
 840 #endif
 841   fputs_unfiltered (_("\n\
 842 For more information, type \"help\" from within GDB, or consult the\n\
 843 GDB manual (available as on-line info or a printed manual).\n\
 844 Report bugs to \"bug-gdb@gnu.org\".\
 845 "), stream);
 846 }