gdb/main.c

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