gdb/main.c

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