1d77bd38648cbee18d4635a0603b5ec2f41d4074
[platform/upstream/binutils.git] / 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 /* Type of the command callback passed to catch_command_errors.  */
341
342 typedef void (catch_command_errors_ftype) (char *, int);
343
344 /* Wrap calls to commands run before the event loop is started.  */
345
346 static int
347 catch_command_errors (catch_command_errors_ftype *command,
348                       char *arg, int from_tty, return_mask mask)
349 {
350   volatile struct gdb_exception e;
351
352   TRY_CATCH (e, mask)
353     {
354       command (arg, from_tty);
355     }
356   exception_print (gdb_stderr, e);
357   if (e.reason < 0)
358     return 0;
359   return 1;
360 }
361
362 /* Type of the command callback passed to catch_command_errors_const.  */
363
364 typedef void (catch_command_errors_const_ftype) (const char *, int);
365
366 /* Like catch_command_errors, but works with const command and args.  */
367
368 static int
369 catch_command_errors_const (catch_command_errors_const_ftype *command,
370                             const char *arg, int from_tty, return_mask mask)
371 {
372   volatile struct gdb_exception e;
373
374   TRY_CATCH (e, mask)
375     {
376       command (arg, from_tty);
377     }
378   exception_print (gdb_stderr, e);
379   if (e.reason < 0)
380     return 0;
381   return 1;
382 }
383
384 /* Arguments of --command option and its counterpart.  */
385 typedef struct cmdarg {
386   /* Type of this option.  */
387   enum {
388     /* Option type -x.  */
389     CMDARG_FILE,
390
391     /* Option type -ex.  */
392     CMDARG_COMMAND,
393
394     /* Option type -ix.  */
395     CMDARG_INIT_FILE,
396     
397     /* Option type -iex.  */
398     CMDARG_INIT_COMMAND
399   } type;
400
401   /* Value of this option - filename or the GDB command itself.  String memory
402      is not owned by this structure despite it is 'const'.  */
403   char *string;
404 } cmdarg_s;
405
406 /* Define type VEC (cmdarg_s).  */
407 DEF_VEC_O (cmdarg_s);
408
409 static int
410 captured_main (void *data)
411 {
412   struct captured_main_args *context = data;
413   int argc = context->argc;
414   char **argv = context->argv;
415   static int quiet = 0;
416   static int set_args = 0;
417   static int inhibit_home_gdbinit = 0;
418
419   /* Pointers to various arguments from command line.  */
420   char *symarg = NULL;
421   char *execarg = NULL;
422   char *pidarg = NULL;
423   char *corearg = NULL;
424   char *pid_or_core_arg = NULL;
425   char *cdarg = NULL;
426   char *ttyarg = NULL;
427
428   /* These are static so that we can take their address in an
429      initializer.  */
430   static int print_help;
431   static int print_version;
432   static int print_configuration;
433
434   /* Pointers to all arguments of --command option.  */
435   VEC (cmdarg_s) *cmdarg_vec = NULL;
436   struct cmdarg *cmdarg_p;
437
438   /* Indices of all arguments of --directory option.  */
439   char **dirarg;
440   /* Allocated size.  */
441   int dirsize;
442   /* Number of elements used.  */
443   int ndir;
444
445   /* gdb init files.  */
446   const char *system_gdbinit;
447   const char *home_gdbinit;
448   const char *local_gdbinit;
449
450   int i;
451   int save_auto_load;
452   struct objfile *objfile;
453
454   struct cleanup *pre_stat_chain;
455
456 #ifdef HAVE_SBRK
457   /* Set this before calling make_command_stats_cleanup.  */
458   lim_at_start = (char *) sbrk (0);
459 #endif
460
461   pre_stat_chain = make_command_stats_cleanup (0);
462
463 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
464   setlocale (LC_MESSAGES, "");
465 #endif
466 #if defined (HAVE_SETLOCALE)
467   setlocale (LC_CTYPE, "");
468 #endif
469   bindtextdomain (PACKAGE, LOCALEDIR);
470   textdomain (PACKAGE);
471
472   bfd_init ();
473   notice_open_fds ();
474
475   make_cleanup (VEC_cleanup (cmdarg_s), &cmdarg_vec);
476   dirsize = 1;
477   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
478   ndir = 0;
479
480   clear_quit_flag ();
481   saved_command_line = (char *) xmalloc (saved_command_line_size);
482   saved_command_line[0] = '\0';
483   instream = stdin;
484
485 #ifdef __MINGW32__
486   /* Ensure stderr is unbuffered.  A Cygwin pty or pipe is implemented
487      as a Windows pipe, and Windows buffers on pipes.  */
488   setvbuf (stderr, NULL, _IONBF, BUFSIZ);
489 #endif
490
491   gdb_stdout = stdio_fileopen (stdout);
492   gdb_stderr = stderr_fileopen ();
493
494   gdb_stdlog = gdb_stderr;      /* for moment */
495   gdb_stdtarg = gdb_stderr;     /* for moment */
496   gdb_stdin = stdio_fileopen (stdin);
497   gdb_stdtargerr = gdb_stderr;  /* for moment */
498   gdb_stdtargin = gdb_stdin;    /* for moment */
499
500 #ifdef __MINGW32__
501   /* On Windows, argv[0] is not necessarily set to absolute form when
502      GDB is found along PATH, without which relocation doesn't work.  */
503   gdb_program_name = windows_get_absolute_argv0 (argv[0]);
504 #else
505   gdb_program_name = xstrdup (argv[0]);
506 #endif
507
508   if (! getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)))
509     /* Don't use *_filtered or warning() (which relies on
510        current_target) until after initialize_all_files().  */
511     fprintf_unfiltered (gdb_stderr,
512                         _("%s: warning: error finding "
513                           "working directory: %s\n"),
514                         argv[0], safe_strerror (errno));
515     
516   current_directory = gdb_dirbuf;
517
518   /* Set the sysroot path.  */
519   gdb_sysroot = relocate_gdb_directory (TARGET_SYSTEM_ROOT,
520                                         TARGET_SYSTEM_ROOT_RELOCATABLE);
521
522   debug_file_directory = relocate_gdb_directory (DEBUGDIR,
523                                                  DEBUGDIR_RELOCATABLE);
524
525   gdb_datadir = relocate_gdb_directory (GDB_DATADIR,
526                                         GDB_DATADIR_RELOCATABLE);
527
528 #ifdef WITH_PYTHON_PATH
529   {
530     /* For later use in helping Python find itself.  */
531     char *tmp = concat (WITH_PYTHON_PATH, SLASH_STRING, "lib", NULL);
532
533     python_libdir = relocate_gdb_directory (tmp, PYTHON_PATH_RELOCATABLE);
534     xfree (tmp);
535   }
536 #endif
537
538 #ifdef RELOC_SRCDIR
539   add_substitute_path_rule (RELOC_SRCDIR,
540                             make_relative_prefix (gdb_program_name, BINDIR,
541                                                   RELOC_SRCDIR));
542 #endif
543
544   /* There will always be an interpreter.  Either the one passed into
545      this captured main, or one specified by the user at start up, or
546      the console.  Initialize the interpreter to the one requested by 
547      the application.  */
548   interpreter_p = xstrdup (context->interpreter_p);
549
550   /* Parse arguments and options.  */
551   {
552     int c;
553     /* When var field is 0, use flag field to record the equivalent
554        short option (or arbitrary numbers starting at 10 for those
555        with no equivalent).  */
556     enum {
557       OPT_SE = 10,
558       OPT_CD,
559       OPT_ANNOTATE,
560       OPT_STATISTICS,
561       OPT_TUI,
562       OPT_NOWINDOWS,
563       OPT_WINDOWS,
564       OPT_IX,
565       OPT_IEX
566     };
567     static struct option long_options[] =
568     {
569       {"tui", no_argument, 0, OPT_TUI},
570       {"xdb", no_argument, &xdb_commands, 1},
571       {"dbx", no_argument, &dbx_commands, 1},
572       {"readnow", no_argument, &readnow_symbol_files, 1},
573       {"r", no_argument, &readnow_symbol_files, 1},
574       {"quiet", no_argument, &quiet, 1},
575       {"q", no_argument, &quiet, 1},
576       {"silent", no_argument, &quiet, 1},
577       {"nh", no_argument, &inhibit_home_gdbinit, 1},
578       {"nx", no_argument, &inhibit_gdbinit, 1},
579       {"n", no_argument, &inhibit_gdbinit, 1},
580       {"batch-silent", no_argument, 0, 'B'},
581       {"batch", no_argument, &batch_flag, 1},
582
583     /* This is a synonym for "--annotate=1".  --annotate is now
584        preferred, but keep this here for a long time because people
585        will be running emacses which use --fullname.  */
586       {"fullname", no_argument, 0, 'f'},
587       {"f", no_argument, 0, 'f'},
588
589       {"annotate", required_argument, 0, OPT_ANNOTATE},
590       {"help", no_argument, &print_help, 1},
591       {"se", required_argument, 0, OPT_SE},
592       {"symbols", required_argument, 0, 's'},
593       {"s", required_argument, 0, 's'},
594       {"exec", required_argument, 0, 'e'},
595       {"e", required_argument, 0, 'e'},
596       {"core", required_argument, 0, 'c'},
597       {"c", required_argument, 0, 'c'},
598       {"pid", required_argument, 0, 'p'},
599       {"p", required_argument, 0, 'p'},
600       {"command", required_argument, 0, 'x'},
601       {"eval-command", required_argument, 0, 'X'},
602       {"version", no_argument, &print_version, 1},
603       {"configuration", no_argument, &print_configuration, 1},
604       {"x", required_argument, 0, 'x'},
605       {"ex", required_argument, 0, 'X'},
606       {"init-command", required_argument, 0, OPT_IX},
607       {"init-eval-command", required_argument, 0, OPT_IEX},
608       {"ix", required_argument, 0, OPT_IX},
609       {"iex", required_argument, 0, OPT_IEX},
610 #ifdef GDBTK
611       {"tclcommand", required_argument, 0, 'z'},
612       {"enable-external-editor", no_argument, 0, 'y'},
613       {"editor-command", required_argument, 0, 'w'},
614 #endif
615       {"ui", required_argument, 0, 'i'},
616       {"interpreter", required_argument, 0, 'i'},
617       {"i", required_argument, 0, 'i'},
618       {"directory", required_argument, 0, 'd'},
619       {"d", required_argument, 0, 'd'},
620       {"data-directory", required_argument, 0, 'D'},
621       {"D", required_argument, 0, 'D'},
622       {"cd", required_argument, 0, OPT_CD},
623       {"tty", required_argument, 0, 't'},
624       {"baud", required_argument, 0, 'b'},
625       {"b", required_argument, 0, 'b'},
626       {"nw", no_argument, NULL, OPT_NOWINDOWS},
627       {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
628       {"w", no_argument, NULL, OPT_WINDOWS},
629       {"windows", no_argument, NULL, OPT_WINDOWS},
630       {"statistics", no_argument, 0, OPT_STATISTICS},
631       {"write", no_argument, &write_files, 1},
632       {"args", no_argument, &set_args, 1},
633       {"l", required_argument, 0, 'l'},
634       {"return-child-result", no_argument, &return_child_result, 1},
635       {0, no_argument, 0, 0}
636     };
637
638     while (1)
639       {
640         int option_index;
641
642         c = getopt_long_only (argc, argv, "",
643                               long_options, &option_index);
644         if (c == EOF || set_args)
645           break;
646
647         /* Long option that takes an argument.  */
648         if (c == 0 && long_options[option_index].flag == 0)
649           c = long_options[option_index].val;
650
651         switch (c)
652           {
653           case 0:
654             /* Long option that just sets a flag.  */
655             break;
656           case OPT_SE:
657             symarg = optarg;
658             execarg = optarg;
659             break;
660           case OPT_CD:
661             cdarg = optarg;
662             break;
663           case OPT_ANNOTATE:
664             /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
665             annotation_level = atoi (optarg);
666             break;
667           case OPT_STATISTICS:
668             /* Enable the display of both time and space usage.  */
669             set_per_command_time (1);
670             set_per_command_space (1);
671             break;
672           case OPT_TUI:
673             /* --tui is equivalent to -i=tui.  */
674 #ifdef TUI
675             xfree (interpreter_p);
676             interpreter_p = xstrdup (INTERP_TUI);
677 #else
678             fprintf_unfiltered (gdb_stderr,
679                                 _("%s: TUI mode is not supported\n"),
680                                 argv[0]);
681             exit (1);
682 #endif
683             break;
684           case OPT_WINDOWS:
685             /* FIXME: cagney/2003-03-01: Not sure if this option is
686                actually useful, and if it is, what it should do.  */
687 #ifdef GDBTK
688             /* --windows is equivalent to -i=insight.  */
689             xfree (interpreter_p);
690             interpreter_p = xstrdup (INTERP_INSIGHT);
691 #endif
692             break;
693           case OPT_NOWINDOWS:
694             /* -nw is equivalent to -i=console.  */
695             xfree (interpreter_p);
696             interpreter_p = xstrdup (INTERP_CONSOLE);
697             break;
698           case 'f':
699             annotation_level = 1;
700             break;
701           case 's':
702             symarg = optarg;
703             break;
704           case 'e':
705             execarg = optarg;
706             break;
707           case 'c':
708             corearg = optarg;
709             break;
710           case 'p':
711             pidarg = optarg;
712             break;
713           case 'x':
714             {
715               struct cmdarg cmdarg = { CMDARG_FILE, optarg };
716
717               VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
718             }
719             break;
720           case 'X':
721             {
722               struct cmdarg cmdarg = { CMDARG_COMMAND, optarg };
723
724               VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
725             }
726             break;
727           case OPT_IX:
728             {
729               struct cmdarg cmdarg = { CMDARG_INIT_FILE, optarg };
730
731               VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
732             }
733             break;
734           case OPT_IEX:
735             {
736               struct cmdarg cmdarg = { CMDARG_INIT_COMMAND, optarg };
737
738               VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
739             }
740             break;
741           case 'B':
742             batch_flag = batch_silent = 1;
743             gdb_stdout = ui_file_new();
744             break;
745           case 'D':
746             if (optarg[0] == '\0')
747               {
748                 fprintf_unfiltered (gdb_stderr,
749                                     _("%s: empty path for"
750                                       " `--data-directory'\n"),
751                                     argv[0]);
752                 exit (1);
753               }
754             set_gdb_data_directory (optarg);
755             gdb_datadir_provided = 1;
756             break;
757 #ifdef GDBTK
758           case 'z':
759             {
760               extern int gdbtk_test (char *);
761
762               if (!gdbtk_test (optarg))
763                 {
764                   fprintf_unfiltered (gdb_stderr,
765                                       _("%s: unable to load "
766                                         "tclcommand file \"%s\""),
767                                       argv[0], optarg);
768                   exit (1);
769                 }
770               break;
771             }
772           case 'y':
773             /* Backwards compatibility only.  */
774             break;
775           case 'w':
776             {
777               /* Set the external editor commands when gdb is farming out files
778                  to be edited by another program.  */
779               extern char *external_editor_command;
780
781               external_editor_command = xstrdup (optarg);
782               break;
783             }
784 #endif /* GDBTK */
785           case 'i':
786             xfree (interpreter_p);
787             interpreter_p = xstrdup (optarg);
788             break;
789           case 'd':
790             dirarg[ndir++] = optarg;
791             if (ndir >= dirsize)
792               {
793                 dirsize *= 2;
794                 dirarg = (char **) xrealloc ((char *) dirarg,
795                                              dirsize * sizeof (*dirarg));
796               }
797             break;
798           case 't':
799             ttyarg = optarg;
800             break;
801           case 'q':
802             quiet = 1;
803             break;
804           case 'b':
805             {
806               int i;
807               char *p;
808
809               i = strtol (optarg, &p, 0);
810               if (i == 0 && p == optarg)
811
812                 /* Don't use *_filtered or warning() (which relies on
813                    current_target) until after initialize_all_files().  */
814
815                 fprintf_unfiltered
816                   (gdb_stderr,
817                    _("warning: could not set baud rate to `%s'.\n"), optarg);
818               else
819                 baud_rate = i;
820             }
821             break;
822           case 'l':
823             {
824               int i;
825               char *p;
826
827               i = strtol (optarg, &p, 0);
828               if (i == 0 && p == optarg)
829
830                 /* Don't use *_filtered or warning() (which relies on
831                    current_target) until after initialize_all_files().  */
832
833                 fprintf_unfiltered (gdb_stderr,
834                                     _("warning: could not set "
835                                       "timeout limit to `%s'.\n"), optarg);
836               else
837                 remote_timeout = i;
838             }
839             break;
840
841           case '?':
842             fprintf_unfiltered (gdb_stderr,
843                                 _("Use `%s --help' for a "
844                                   "complete list of options.\n"),
845                                 argv[0]);
846             exit (1);
847           }
848       }
849
850     if (batch_flag)
851       quiet = 1;
852   }
853
854   /* Try to set up an alternate signal stack for SIGSEGV handlers.  */
855   setup_alternate_signal_stack ();
856
857   /* Initialize all files.  Give the interpreter a chance to take
858      control of the console via the deprecated_init_ui_hook ().  */
859   gdb_init (gdb_program_name);
860
861   /* Now that gdb_init has created the initial inferior, we're in
862      position to set args for that inferior.  */
863   if (set_args)
864     {
865       /* The remaining options are the command-line options for the
866          inferior.  The first one is the sym/exec file, and the rest
867          are arguments.  */
868       if (optind >= argc)
869         {
870           fprintf_unfiltered (gdb_stderr,
871                               _("%s: `--args' specified but "
872                                 "no program specified\n"),
873                               argv[0]);
874           exit (1);
875         }
876       symarg = argv[optind];
877       execarg = argv[optind];
878       ++optind;
879       set_inferior_args_vector (argc - optind, &argv[optind]);
880     }
881   else
882     {
883       /* OK, that's all the options.  */
884
885       /* The first argument, if specified, is the name of the
886          executable.  */
887       if (optind < argc)
888         {
889           symarg = argv[optind];
890           execarg = argv[optind];
891           optind++;
892         }
893
894       /* If the user hasn't already specified a PID or the name of a
895          core file, then a second optional argument is allowed.  If
896          present, this argument should be interpreted as either a
897          PID or a core file, whichever works.  */
898       if (pidarg == NULL && corearg == NULL && optind < argc)
899         {
900           pid_or_core_arg = argv[optind];
901           optind++;
902         }
903
904       /* Any argument left on the command line is unexpected and
905          will be ignored.  Inform the user.  */
906       if (optind < argc)
907         fprintf_unfiltered (gdb_stderr,
908                             _("Excess command line "
909                               "arguments ignored. (%s%s)\n"),
910                             argv[optind],
911                             (optind == argc - 1) ? "" : " ...");
912     }
913
914   /* Lookup gdbinit files.  Note that the gdbinit file name may be
915      overriden during file initialization, so get_init_files should be
916      called after gdb_init.  */
917   get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
918
919   /* Do these (and anything which might call wrap_here or *_filtered)
920      after initialize_all_files() but before the interpreter has been
921      installed.  Otherwize the help/version messages will be eaten by
922      the interpreter's output handler.  */
923
924   if (print_version)
925     {
926       print_gdb_version (gdb_stdout);
927       wrap_here ("");
928       printf_filtered ("\n");
929       exit (0);
930     }
931
932   if (print_help)
933     {
934       print_gdb_help (gdb_stdout);
935       fputs_unfiltered ("\n", gdb_stdout);
936       exit (0);
937     }
938
939   if (print_configuration)
940     {
941       print_gdb_configuration (gdb_stdout);
942       wrap_here ("");
943       printf_filtered ("\n");
944       exit (0);
945     }
946
947   /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
948      GDB retain the old MI1 interpreter startup behavior.  Output the
949      copyright message before the interpreter is installed.  That way
950      it isn't encapsulated in MI output.  */
951   if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
952     {
953       /* Print all the junk at the top, with trailing "..." if we are
954          about to read a symbol file (possibly slowly).  */
955       print_gdb_version (gdb_stdout);
956       if (symarg)
957         printf_filtered ("..");
958       wrap_here ("");
959       printf_filtered ("\n");
960       gdb_flush (gdb_stdout);   /* Force to screen during slow
961                                    operations.  */
962     }
963
964   /* Install the default UI.  All the interpreters should have had a
965      look at things by now.  Initialize the default interpreter.  */
966
967   {
968     /* Find it.  */
969     struct interp *interp = interp_lookup (interpreter_p);
970
971     if (interp == NULL)
972       error (_("Interpreter `%s' unrecognized"), interpreter_p);
973     /* Install it.  */
974     if (!interp_set (interp, 1))
975       {
976         fprintf_unfiltered (gdb_stderr,
977                             "Interpreter `%s' failed to initialize.\n",
978                             interpreter_p);
979         exit (1);
980       }
981   }
982
983   /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
984      GDB retain the old MI1 interpreter startup behavior.  Output the
985      copyright message after the interpreter is installed when it is
986      any sane interpreter.  */
987   if (!quiet && !current_interp_named_p (INTERP_MI1))
988     {
989       /* Print all the junk at the top, with trailing "..." if we are
990          about to read a symbol file (possibly slowly).  */
991       print_gdb_version (gdb_stdout);
992       if (symarg)
993         printf_filtered ("..");
994       wrap_here ("");
995       printf_filtered ("\n");
996       gdb_flush (gdb_stdout);   /* Force to screen during slow
997                                    operations.  */
998     }
999
1000   /* Set off error and warning messages with a blank line.  */
1001   warning_pre_print = _("\nwarning: ");
1002
1003   /* Read and execute the system-wide gdbinit file, if it exists.
1004      This is done *before* all the command line arguments are
1005      processed; it sets global parameters, which are independent of
1006      what file you are debugging or what directory you are in.  */
1007   if (system_gdbinit && !inhibit_gdbinit)
1008     catch_command_errors_const (source_script, system_gdbinit,
1009                                 0, RETURN_MASK_ALL);
1010
1011   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
1012      *before* all the command line arguments are processed; it sets
1013      global parameters, which are independent of what file you are
1014      debugging or what directory you are in.  */
1015
1016   if (home_gdbinit && !inhibit_gdbinit && !inhibit_home_gdbinit)
1017     catch_command_errors_const (source_script,
1018                                 home_gdbinit, 0, RETURN_MASK_ALL);
1019
1020   /* Process '-ix' and '-iex' options early.  */
1021   for (i = 0; VEC_iterate (cmdarg_s, cmdarg_vec, i, cmdarg_p); i++)
1022     switch (cmdarg_p->type)
1023     {
1024       case CMDARG_INIT_FILE:
1025         catch_command_errors_const (source_script, cmdarg_p->string,
1026                                     !batch_flag, RETURN_MASK_ALL);
1027         break;
1028       case CMDARG_INIT_COMMAND:
1029         catch_command_errors (execute_command, cmdarg_p->string,
1030                               !batch_flag, RETURN_MASK_ALL);
1031         break;
1032     }
1033
1034   /* Now perform all the actions indicated by the arguments.  */
1035   if (cdarg != NULL)
1036     {
1037       catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
1038     }
1039
1040   for (i = 0; i < ndir; i++)
1041     catch_command_errors (directory_switch, dirarg[i], 0, RETURN_MASK_ALL);
1042   xfree (dirarg);
1043
1044   /* Skip auto-loading section-specified scripts until we've sourced
1045      local_gdbinit (which is often used to augment the source search
1046      path).  */
1047   save_auto_load = global_auto_load;
1048   global_auto_load = 0;
1049
1050   if (execarg != NULL
1051       && symarg != NULL
1052       && strcmp (execarg, symarg) == 0)
1053     {
1054       /* The exec file and the symbol-file are the same.  If we can't
1055          open it, better only print one error message.
1056          catch_command_errors returns non-zero on success!  */
1057       if (catch_command_errors (exec_file_attach, execarg,
1058                                 !batch_flag, RETURN_MASK_ALL))
1059         catch_command_errors_const (symbol_file_add_main, symarg,
1060                                     !batch_flag, RETURN_MASK_ALL);
1061     }
1062   else
1063     {
1064       if (execarg != NULL)
1065         catch_command_errors (exec_file_attach, execarg,
1066                               !batch_flag, RETURN_MASK_ALL);
1067       if (symarg != NULL)
1068         catch_command_errors_const (symbol_file_add_main, symarg,
1069                                     !batch_flag, RETURN_MASK_ALL);
1070     }
1071
1072   if (corearg && pidarg)
1073     error (_("Can't attach to process and specify "
1074              "a core file at the same time."));
1075
1076   if (corearg != NULL)
1077     catch_command_errors (core_file_command, corearg,
1078                           !batch_flag, RETURN_MASK_ALL);
1079   else if (pidarg != NULL)
1080     catch_command_errors (attach_command, pidarg,
1081                           !batch_flag, RETURN_MASK_ALL);
1082   else if (pid_or_core_arg)
1083     {
1084       /* The user specified 'gdb program pid' or gdb program core'.
1085          If pid_or_core_arg's first character is a digit, try attach
1086          first and then corefile.  Otherwise try just corefile.  */
1087
1088       if (isdigit (pid_or_core_arg[0]))
1089         {
1090           if (catch_command_errors (attach_command, pid_or_core_arg,
1091                                     !batch_flag, RETURN_MASK_ALL) == 0)
1092             catch_command_errors (core_file_command, pid_or_core_arg,
1093                                   !batch_flag, RETURN_MASK_ALL);
1094         }
1095       else /* Can't be a pid, better be a corefile.  */
1096         catch_command_errors (core_file_command, pid_or_core_arg,
1097                               !batch_flag, RETURN_MASK_ALL);
1098     }
1099
1100   if (ttyarg != NULL)
1101     set_inferior_io_terminal (ttyarg);
1102
1103   /* Error messages should no longer be distinguished with extra output.  */
1104   warning_pre_print = _("warning: ");
1105
1106   /* Read the .gdbinit file in the current directory, *if* it isn't
1107      the same as the $HOME/.gdbinit file (it should exist, also).  */
1108   if (local_gdbinit)
1109     {
1110       auto_load_local_gdbinit_pathname = gdb_realpath (local_gdbinit);
1111
1112       if (!inhibit_gdbinit && auto_load_local_gdbinit
1113           && file_is_auto_load_safe (local_gdbinit,
1114                                      _("auto-load: Loading .gdbinit "
1115                                        "file \"%s\".\n"),
1116                                      local_gdbinit))
1117         {
1118           auto_load_local_gdbinit_loaded = 1;
1119
1120           catch_command_errors_const (source_script, local_gdbinit, 0,
1121                                       RETURN_MASK_ALL);
1122         }
1123     }
1124
1125   /* Now that all .gdbinit's have been read and all -d options have been
1126      processed, we can read any scripts mentioned in SYMARG.
1127      We wait until now because it is common to add to the source search
1128      path in local_gdbinit.  */
1129   global_auto_load = save_auto_load;
1130   ALL_OBJFILES (objfile)
1131     load_auto_scripts_for_objfile (objfile);
1132
1133   /* Process '-x' and '-ex' options.  */
1134   for (i = 0; VEC_iterate (cmdarg_s, cmdarg_vec, i, cmdarg_p); i++)
1135     switch (cmdarg_p->type)
1136     {
1137       case CMDARG_FILE:
1138         catch_command_errors_const (source_script, cmdarg_p->string,
1139                                     !batch_flag, RETURN_MASK_ALL);
1140         break;
1141       case CMDARG_COMMAND:
1142         catch_command_errors (execute_command, cmdarg_p->string,
1143                               !batch_flag, RETURN_MASK_ALL);
1144         break;
1145     }
1146
1147   /* Read in the old history after all the command files have been
1148      read.  */
1149   init_history ();
1150
1151   if (batch_flag)
1152     {
1153       /* We have hit the end of the batch file.  */
1154       quit_force (NULL, 0);
1155     }
1156
1157   /* Show time and/or space usage.  */
1158   do_cleanups (pre_stat_chain);
1159
1160   /* NOTE: cagney/1999-11-07: There is probably no reason for not
1161      moving this loop and the code found in captured_command_loop()
1162      into the command_loop() proper.  The main thing holding back that
1163      change - SET_TOP_LEVEL() - has been eliminated.  */
1164   while (1)
1165     {
1166       catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
1167     }
1168   /* No exit -- exit is through quit_command.  */
1169 }
1170
1171 int
1172 gdb_main (struct captured_main_args *args)
1173 {
1174   catch_errors (captured_main, args, "", RETURN_MASK_ALL);
1175   /* The only way to end up here is by an error (normal exit is
1176      handled by quit_force()), hence always return an error status.  */
1177   return 1;
1178 }
1179
1180
1181 /* Don't use *_filtered for printing help.  We don't want to prompt
1182    for continue no matter how small the screen or how much we're going
1183    to print.  */
1184
1185 static void
1186 print_gdb_help (struct ui_file *stream)
1187 {
1188   const char *system_gdbinit;
1189   const char *home_gdbinit;
1190   const char *local_gdbinit;
1191
1192   get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
1193
1194   /* Note: The options in the list below are only approximately sorted
1195      in the alphabetical order, so as to group closely related options
1196      together.  */
1197   fputs_unfiltered (_("\
1198 This is the GNU debugger.  Usage:\n\n\
1199     gdb [options] [executable-file [core-file or process-id]]\n\
1200     gdb [options] --args executable-file [inferior-arguments ...]\n\n\
1201 "), stream);
1202   fputs_unfiltered (_("\
1203 Selection of debuggee and its files:\n\n\
1204   --args             Arguments after executable-file are passed to inferior\n\
1205   --core=COREFILE    Analyze the core dump COREFILE.\n\
1206   --exec=EXECFILE    Use EXECFILE as the executable.\n\
1207   --pid=PID          Attach to running process PID.\n\
1208   --directory=DIR    Search for source files in DIR.\n\
1209   --se=FILE          Use FILE as symbol file and executable file.\n\
1210   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
1211   --readnow          Fully read symbol files on first access.\n\
1212   --write            Set writing into executable and core files.\n\n\
1213 "), stream);
1214   fputs_unfiltered (_("\
1215 Initial commands and command files:\n\n\
1216   --command=FILE, -x Execute GDB commands from FILE.\n\
1217   --init-command=FILE, -ix\n\
1218                      Like -x but execute commands before loading inferior.\n\
1219   --eval-command=COMMAND, -ex\n\
1220                      Execute a single GDB command.\n\
1221                      May be used multiple times and in conjunction\n\
1222                      with --command.\n\
1223   --init-eval-command=COMMAND, -iex\n\
1224                      Like -ex but before loading inferior.\n\
1225   --nh               Do not read ~/.gdbinit.\n\
1226   --nx               Do not read any .gdbinit files in any directory.\n\n\
1227 "), stream);
1228   fputs_unfiltered (_("\
1229 Output and user interface control:\n\n\
1230   --fullname         Output information used by emacs-GDB interface.\n\
1231   --interpreter=INTERP\n\
1232                      Select a specific interpreter / user interface\n\
1233   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
1234   -w                 Use the GUI interface.\n\
1235   --nw               Do not use the GUI interface.\n\
1236 "), stream);
1237 #if defined(TUI)
1238   fputs_unfiltered (_("\
1239   --tui              Use a terminal user interface.\n\
1240 "), stream);
1241 #endif
1242   fputs_unfiltered (_("\
1243   --dbx              DBX compatibility mode.\n\
1244   --xdb              XDB compatibility mode.\n\
1245   -q, --quiet, --silent\n\
1246                      Do not print version number on startup.\n\n\
1247 "), stream);
1248   fputs_unfiltered (_("\
1249 Operating modes:\n\n\
1250   --batch            Exit after processing options.\n\
1251   --batch-silent     Like --batch, but suppress all gdb stdout output.\n\
1252   --return-child-result\n\
1253                      GDB exit code will be the child's exit code.\n\
1254   --configuration    Print details about GDB configuration and then exit.\n\
1255   --help             Print this message and then exit.\n\
1256   --version          Print version information and then exit.\n\n\
1257 Remote debugging options:\n\n\
1258   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
1259   -l TIMEOUT         Set timeout in seconds for remote debugging.\n\n\
1260 Other options:\n\n\
1261   --cd=DIR           Change current directory to DIR.\n\
1262   --data-directory=DIR, -D\n\
1263                      Set GDB's data-directory to DIR.\n\
1264 "), stream);
1265   fputs_unfiltered (_("\n\
1266 At startup, GDB reads the following init files and executes their commands:\n\
1267 "), stream);
1268   if (system_gdbinit)
1269     fprintf_unfiltered (stream, _("\
1270    * system-wide init file: %s\n\
1271 "), system_gdbinit);
1272   if (home_gdbinit)
1273     fprintf_unfiltered (stream, _("\
1274    * user-specific init file: %s\n\
1275 "), home_gdbinit);
1276   if (local_gdbinit)
1277     fprintf_unfiltered (stream, _("\
1278    * local init file (see also 'set auto-load local-gdbinit'): ./%s\n\
1279 "), local_gdbinit);
1280   fputs_unfiltered (_("\n\
1281 For more information, type \"help\" from within GDB, or consult the\n\
1282 GDB manual (available as on-line info or a printed manual).\n\
1283 "), stream);
1284   if (REPORT_BUGS_TO[0] && stream == gdb_stdout)
1285     fprintf_unfiltered (stream, _("\
1286 Report bugs to \"%s\".\n\
1287 "), REPORT_BUGS_TO);
1288 }