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