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