gdb/main.c

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