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