1 /* Top level stuff for GDB, the GNU debugger.
3 Copyright (C) 1986-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
27 #include "exceptions.h"
30 #include <sys/types.h>
35 #include "event-loop.h"
41 #include "cli/cli-cmds.h"
43 #include "auto-load.h"
46 #include "filenames.h"
47 #include "filestuff.h"
49 #include "event-top.h"
51 /* The selected interpreter. This will be used as a set command
52 variable, so it should always be malloc'ed - since
53 do_setshow_command will free it. */
56 /* Whether xdb commands will be handled. */
59 /* Whether dbx commands will be handled. */
62 /* System root path, used to find libraries etc. */
63 char *gdb_sysroot
= 0;
65 /* GDB datadir, used to store data files. */
66 char *gdb_datadir
= 0;
68 /* Non-zero if GDB_DATADIR was provided on the command line.
69 This doesn't track whether data-directory is set later from the
70 command line, but we don't reread system.gdbinit when that happens. */
71 static int gdb_datadir_provided
= 0;
73 /* If gdb was configured with --with-python=/path,
74 the possibly relocated path to python's lib directory. */
75 char *python_libdir
= 0;
77 struct ui_file
*gdb_stdout
;
78 struct ui_file
*gdb_stderr
;
79 struct ui_file
*gdb_stdlog
;
80 struct ui_file
*gdb_stdin
;
81 /* Target IO streams. */
82 struct ui_file
*gdb_stdtargin
;
83 struct ui_file
*gdb_stdtarg
;
84 struct ui_file
*gdb_stdtargerr
;
86 /* True if --batch or --batch-silent was seen. */
89 /* Support for the --batch-silent option. */
92 /* Support for --return-child-result option.
93 Set the default to -1 to return error in the case
94 that the program does not run or does not complete. */
95 int return_child_result
= 0;
96 int return_child_result_value
= -1;
99 /* GDB as it has been invoked from the command line (i.e. argv[0]). */
100 static char *gdb_program_name
;
102 /* Return read only pointer to GDB_PROGRAM_NAME. */
104 get_gdb_program_name (void)
106 return gdb_program_name
;
109 static void print_gdb_help (struct ui_file
*);
111 /* Set the data-directory parameter to NEW_DATADIR.
112 If NEW_DATADIR is not a directory then a warning is printed.
113 We don't signal an error for backward compatibility. */
116 set_gdb_data_directory (const char *new_datadir
)
120 if (stat (new_datadir
, &st
) < 0)
122 int save_errno
= errno
;
124 fprintf_unfiltered (gdb_stderr
, "Warning: ");
125 print_sys_errmsg (new_datadir
, save_errno
);
127 else if (!S_ISDIR (st
.st_mode
))
128 warning (_("%s is not a directory."), new_datadir
);
131 gdb_datadir
= gdb_realpath (new_datadir
);
133 /* gdb_realpath won't return an absolute path if the path doesn't exist,
134 but we still want to record an absolute path here. If the user entered
135 "../foo" and "../foo" doesn't exist then we'll record $(pwd)/../foo which
136 isn't canonical, but that's ok. */
137 if (!IS_ABSOLUTE_PATH (gdb_datadir
))
139 char *abs_datadir
= gdb_abspath (gdb_datadir
);
142 gdb_datadir
= abs_datadir
;
146 /* Relocate a file or directory. PROGNAME is the name by which gdb
147 was invoked (i.e., argv[0]). INITIAL is the default value for the
148 file or directory. FLAG is true if the value is relocatable, false
149 otherwise. Returns a newly allocated string; this may return NULL
150 under the same conditions as make_relative_prefix. */
153 relocate_path (const char *progname
, const char *initial
, int flag
)
156 return make_relative_prefix (progname
, BINDIR
, initial
);
157 return xstrdup (initial
);
160 /* Like relocate_path, but specifically checks for a directory.
161 INITIAL is relocated according to the rules of relocate_path. If
162 the result is a directory, it is used; otherwise, INITIAL is used.
163 The chosen directory is then canonicalized using lrealpath. This
164 function always returns a newly-allocated string. */
167 relocate_gdb_directory (const char *initial
, int flag
)
171 dir
= relocate_path (gdb_program_name
, initial
, flag
);
176 if (*dir
== '\0' || stat (dir
, &s
) != 0 || !S_ISDIR (s
.st_mode
))
183 dir
= xstrdup (initial
);
185 /* Canonicalize the directory. */
188 char *canon_sysroot
= lrealpath (dir
);
200 /* Compute the locations of init files that GDB should source and
201 return them in SYSTEM_GDBINIT, HOME_GDBINIT, LOCAL_GDBINIT. If
202 there is no system gdbinit (resp. home gdbinit and local gdbinit)
203 to be loaded, then SYSTEM_GDBINIT (resp. HOME_GDBINIT and
204 LOCAL_GDBINIT) is set to NULL. */
206 get_init_files (const char **system_gdbinit
,
207 const char **home_gdbinit
,
208 const char **local_gdbinit
)
210 static const char *sysgdbinit
= NULL
;
211 static char *homeinit
= NULL
;
212 static const char *localinit
= NULL
;
213 static int initialized
= 0;
217 struct stat homebuf
, cwdbuf
, s
;
220 if (SYSTEM_GDBINIT
[0])
222 int datadir_len
= strlen (GDB_DATADIR
);
223 int sys_gdbinit_len
= strlen (SYSTEM_GDBINIT
);
224 char *relocated_sysgdbinit
;
226 /* If SYSTEM_GDBINIT lives in data-directory, and data-directory
227 has been provided, search for SYSTEM_GDBINIT there. */
228 if (gdb_datadir_provided
229 && datadir_len
< sys_gdbinit_len
230 && filename_ncmp (SYSTEM_GDBINIT
, GDB_DATADIR
, datadir_len
) == 0
231 && IS_DIR_SEPARATOR (SYSTEM_GDBINIT
[datadir_len
]))
233 /* Append the part of SYSTEM_GDBINIT that follows GDB_DATADIR
235 char *tmp_sys_gdbinit
= xstrdup (SYSTEM_GDBINIT
+ datadir_len
);
238 for (p
= tmp_sys_gdbinit
; IS_DIR_SEPARATOR (*p
); ++p
)
240 relocated_sysgdbinit
= concat (gdb_datadir
, SLASH_STRING
, p
,
242 xfree (tmp_sys_gdbinit
);
246 relocated_sysgdbinit
= relocate_path (gdb_program_name
,
248 SYSTEM_GDBINIT_RELOCATABLE
);
250 if (relocated_sysgdbinit
&& stat (relocated_sysgdbinit
, &s
) == 0)
251 sysgdbinit
= relocated_sysgdbinit
;
253 xfree (relocated_sysgdbinit
);
256 homedir
= getenv ("HOME");
258 /* If the .gdbinit file in the current directory is the same as
259 the $HOME/.gdbinit file, it should not be sourced. homebuf
260 and cwdbuf are used in that purpose. Make sure that the stats
261 are zero in case one of them fails (this guarantees that they
262 won't match if either exists). */
264 memset (&homebuf
, 0, sizeof (struct stat
));
265 memset (&cwdbuf
, 0, sizeof (struct stat
));
269 homeinit
= xstrprintf ("%s/%s", homedir
, gdbinit
);
270 if (stat (homeinit
, &homebuf
) != 0)
277 if (stat (gdbinit
, &cwdbuf
) == 0)
280 || memcmp ((char *) &homebuf
, (char *) &cwdbuf
,
281 sizeof (struct stat
)))
288 *system_gdbinit
= sysgdbinit
;
289 *home_gdbinit
= homeinit
;
290 *local_gdbinit
= localinit
;
293 /* Try to set up an alternate signal stack for SIGSEGV handlers.
294 This allows us to handle SIGSEGV signals generated when the
295 normal process stack is exhausted. If this stack is not set
296 up (sigaltstack is unavailable or fails) and a SIGSEGV is
297 generated when the normal stack is exhausted then the program
298 will behave as though no SIGSEGV handler was installed. */
301 setup_alternate_signal_stack (void)
303 #ifdef HAVE_SIGALTSTACK
306 ss
.ss_sp
= xmalloc (SIGSTKSZ
);
307 ss
.ss_size
= SIGSTKSZ
;
310 sigaltstack(&ss
, NULL
);
314 /* Call command_loop. If it happens to return, pass that through as a
315 non-zero return status. */
318 captured_command_loop (void *data
)
320 /* Top-level execution commands can be run in the background from
322 interpreter_async
= 1;
324 current_interp_command_loop ();
325 /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
326 would clean things up (restoring the cleanup chain) to the state
327 they were just prior to the call. Technically, this means that
328 the do_cleanups() below is redundant. Unfortunately, many FUNCs
329 are not that well behaved. do_cleanups should either be replaced
330 with a do_cleanups call (to cover the problem) or an assertion
331 check to detect bad FUNCs code. */
332 do_cleanups (all_cleanups ());
333 /* If the command_loop returned, normally (rather than threw an
334 error) we try to quit. If the quit is aborted, catch_errors()
335 which called this catch the signal and restart the command
337 quit_command (NULL
, instream
== stdin
);
341 /* Handle command errors thrown from within
342 catch_command_errors/catch_command_errors_const. */
345 handle_command_errors (volatile struct gdb_exception e
)
349 exception_print (gdb_stderr
, e
);
351 /* If any exception escaped to here, we better enable stdin.
352 Otherwise, any command that calls async_disable_stdin, and
353 then throws, will leave stdin inoperable. */
354 async_enable_stdin ();
360 /* Type of the command callback passed to catch_command_errors. */
362 typedef void (catch_command_errors_ftype
) (char *, int);
364 /* Wrap calls to commands run before the event loop is started. */
367 catch_command_errors (catch_command_errors_ftype
*command
,
368 char *arg
, int from_tty
, return_mask mask
)
370 volatile struct gdb_exception e
;
374 command (arg
, from_tty
);
376 return handle_command_errors (e
);
379 /* Type of the command callback passed to catch_command_errors_const. */
381 typedef void (catch_command_errors_const_ftype
) (const char *, int);
383 /* Like catch_command_errors, but works with const command and args. */
386 catch_command_errors_const (catch_command_errors_const_ftype
*command
,
387 const char *arg
, int from_tty
, return_mask mask
)
389 volatile struct gdb_exception e
;
393 command (arg
, from_tty
);
395 return handle_command_errors (e
);
398 /* Arguments of --command option and its counterpart. */
399 typedef struct cmdarg
{
400 /* Type of this option. */
402 /* Option type -x. */
405 /* Option type -ex. */
408 /* Option type -ix. */
411 /* Option type -iex. */
415 /* Value of this option - filename or the GDB command itself. String memory
416 is not owned by this structure despite it is 'const'. */
420 /* Define type VEC (cmdarg_s). */
421 DEF_VEC_O (cmdarg_s
);
424 captured_main (void *data
)
426 struct captured_main_args
*context
= data
;
427 int argc
= context
->argc
;
428 char **argv
= context
->argv
;
429 static int quiet
= 0;
430 static int set_args
= 0;
431 static int inhibit_home_gdbinit
= 0;
433 /* Pointers to various arguments from command line. */
435 char *execarg
= NULL
;
437 char *corearg
= NULL
;
438 char *pid_or_core_arg
= NULL
;
442 /* These are static so that we can take their address in an
444 static int print_help
;
445 static int print_version
;
446 static int print_configuration
;
448 /* Pointers to all arguments of --command option. */
449 VEC (cmdarg_s
) *cmdarg_vec
= NULL
;
450 struct cmdarg
*cmdarg_p
;
452 /* Indices of all arguments of --directory option. */
454 /* Allocated size. */
456 /* Number of elements used. */
459 /* gdb init files. */
460 const char *system_gdbinit
;
461 const char *home_gdbinit
;
462 const char *local_gdbinit
;
466 struct objfile
*objfile
;
468 struct cleanup
*pre_stat_chain
;
471 /* Set this before calling make_command_stats_cleanup. */
472 lim_at_start
= (char *) sbrk (0);
475 pre_stat_chain
= make_command_stats_cleanup (0);
477 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
478 setlocale (LC_MESSAGES
, "");
480 #if defined (HAVE_SETLOCALE)
481 setlocale (LC_CTYPE
, "");
483 bindtextdomain (PACKAGE
, LOCALEDIR
);
484 textdomain (PACKAGE
);
489 make_cleanup (VEC_cleanup (cmdarg_s
), &cmdarg_vec
);
491 dirarg
= (char **) xmalloc (dirsize
* sizeof (*dirarg
));
495 saved_command_line
= (char *) xmalloc (saved_command_line_size
);
496 saved_command_line
[0] = '\0';
500 /* Ensure stderr is unbuffered. A Cygwin pty or pipe is implemented
501 as a Windows pipe, and Windows buffers on pipes. */
502 setvbuf (stderr
, NULL
, _IONBF
, BUFSIZ
);
505 gdb_stdout
= stdio_fileopen (stdout
);
506 gdb_stderr
= stderr_fileopen ();
508 gdb_stdlog
= gdb_stderr
; /* for moment */
509 gdb_stdtarg
= gdb_stderr
; /* for moment */
510 gdb_stdin
= stdio_fileopen (stdin
);
511 gdb_stdtargerr
= gdb_stderr
; /* for moment */
512 gdb_stdtargin
= gdb_stdin
; /* for moment */
515 /* On Windows, argv[0] is not necessarily set to absolute form when
516 GDB is found along PATH, without which relocation doesn't work. */
517 gdb_program_name
= windows_get_absolute_argv0 (argv
[0]);
519 gdb_program_name
= xstrdup (argv
[0]);
522 if (! getcwd (gdb_dirbuf
, sizeof (gdb_dirbuf
)))
523 /* Don't use *_filtered or warning() (which relies on
524 current_target) until after initialize_all_files(). */
525 fprintf_unfiltered (gdb_stderr
,
526 _("%s: warning: error finding "
527 "working directory: %s\n"),
528 argv
[0], safe_strerror (errno
));
530 current_directory
= gdb_dirbuf
;
532 /* Set the sysroot path. */
533 gdb_sysroot
= relocate_gdb_directory (TARGET_SYSTEM_ROOT
,
534 TARGET_SYSTEM_ROOT_RELOCATABLE
);
536 debug_file_directory
= relocate_gdb_directory (DEBUGDIR
,
537 DEBUGDIR_RELOCATABLE
);
539 gdb_datadir
= relocate_gdb_directory (GDB_DATADIR
,
540 GDB_DATADIR_RELOCATABLE
);
542 #ifdef WITH_PYTHON_PATH
544 /* For later use in helping Python find itself. */
545 char *tmp
= concat (WITH_PYTHON_PATH
, SLASH_STRING
, "lib", NULL
);
547 python_libdir
= relocate_gdb_directory (tmp
, PYTHON_PATH_RELOCATABLE
);
553 add_substitute_path_rule (RELOC_SRCDIR
,
554 make_relative_prefix (gdb_program_name
, BINDIR
,
558 /* There will always be an interpreter. Either the one passed into
559 this captured main, or one specified by the user at start up, or
560 the console. Initialize the interpreter to the one requested by
562 interpreter_p
= xstrdup (context
->interpreter_p
);
564 /* Parse arguments and options. */
567 /* When var field is 0, use flag field to record the equivalent
568 short option (or arbitrary numbers starting at 10 for those
569 with no equivalent). */
581 static struct option long_options
[] =
583 {"tui", no_argument
, 0, OPT_TUI
},
584 {"xdb", no_argument
, &xdb_commands
, 1},
585 {"dbx", no_argument
, &dbx_commands
, 1},
586 {"readnow", no_argument
, &readnow_symbol_files
, 1},
587 {"r", no_argument
, &readnow_symbol_files
, 1},
588 {"quiet", no_argument
, &quiet
, 1},
589 {"q", no_argument
, &quiet
, 1},
590 {"silent", no_argument
, &quiet
, 1},
591 {"nh", no_argument
, &inhibit_home_gdbinit
, 1},
592 {"nx", no_argument
, &inhibit_gdbinit
, 1},
593 {"n", no_argument
, &inhibit_gdbinit
, 1},
594 {"batch-silent", no_argument
, 0, 'B'},
595 {"batch", no_argument
, &batch_flag
, 1},
597 /* This is a synonym for "--annotate=1". --annotate is now
598 preferred, but keep this here for a long time because people
599 will be running emacses which use --fullname. */
600 {"fullname", no_argument
, 0, 'f'},
601 {"f", no_argument
, 0, 'f'},
603 {"annotate", required_argument
, 0, OPT_ANNOTATE
},
604 {"help", no_argument
, &print_help
, 1},
605 {"se", required_argument
, 0, OPT_SE
},
606 {"symbols", required_argument
, 0, 's'},
607 {"s", required_argument
, 0, 's'},
608 {"exec", required_argument
, 0, 'e'},
609 {"e", required_argument
, 0, 'e'},
610 {"core", required_argument
, 0, 'c'},
611 {"c", required_argument
, 0, 'c'},
612 {"pid", required_argument
, 0, 'p'},
613 {"p", required_argument
, 0, 'p'},
614 {"command", required_argument
, 0, 'x'},
615 {"eval-command", required_argument
, 0, 'X'},
616 {"version", no_argument
, &print_version
, 1},
617 {"configuration", no_argument
, &print_configuration
, 1},
618 {"x", required_argument
, 0, 'x'},
619 {"ex", required_argument
, 0, 'X'},
620 {"init-command", required_argument
, 0, OPT_IX
},
621 {"init-eval-command", required_argument
, 0, OPT_IEX
},
622 {"ix", required_argument
, 0, OPT_IX
},
623 {"iex", required_argument
, 0, OPT_IEX
},
625 {"tclcommand", required_argument
, 0, 'z'},
626 {"enable-external-editor", no_argument
, 0, 'y'},
627 {"editor-command", required_argument
, 0, 'w'},
629 {"ui", required_argument
, 0, 'i'},
630 {"interpreter", required_argument
, 0, 'i'},
631 {"i", required_argument
, 0, 'i'},
632 {"directory", required_argument
, 0, 'd'},
633 {"d", required_argument
, 0, 'd'},
634 {"data-directory", required_argument
, 0, 'D'},
635 {"D", required_argument
, 0, 'D'},
636 {"cd", required_argument
, 0, OPT_CD
},
637 {"tty", required_argument
, 0, 't'},
638 {"baud", required_argument
, 0, 'b'},
639 {"b", required_argument
, 0, 'b'},
640 {"nw", no_argument
, NULL
, OPT_NOWINDOWS
},
641 {"nowindows", no_argument
, NULL
, OPT_NOWINDOWS
},
642 {"w", no_argument
, NULL
, OPT_WINDOWS
},
643 {"windows", no_argument
, NULL
, OPT_WINDOWS
},
644 {"statistics", no_argument
, 0, OPT_STATISTICS
},
645 {"write", no_argument
, &write_files
, 1},
646 {"args", no_argument
, &set_args
, 1},
647 {"l", required_argument
, 0, 'l'},
648 {"return-child-result", no_argument
, &return_child_result
, 1},
649 {0, no_argument
, 0, 0}
656 c
= getopt_long_only (argc
, argv
, "",
657 long_options
, &option_index
);
658 if (c
== EOF
|| set_args
)
661 /* Long option that takes an argument. */
662 if (c
== 0 && long_options
[option_index
].flag
== 0)
663 c
= long_options
[option_index
].val
;
668 /* Long option that just sets a flag. */
678 /* FIXME: what if the syntax is wrong (e.g. not digits)? */
679 annotation_level
= atoi (optarg
);
682 /* Enable the display of both time and space usage. */
683 set_per_command_time (1);
684 set_per_command_space (1);
687 /* --tui is equivalent to -i=tui. */
689 xfree (interpreter_p
);
690 interpreter_p
= xstrdup (INTERP_TUI
);
692 fprintf_unfiltered (gdb_stderr
,
693 _("%s: TUI mode is not supported\n"),
699 /* FIXME: cagney/2003-03-01: Not sure if this option is
700 actually useful, and if it is, what it should do. */
702 /* --windows is equivalent to -i=insight. */
703 xfree (interpreter_p
);
704 interpreter_p
= xstrdup (INTERP_INSIGHT
);
708 /* -nw is equivalent to -i=console. */
709 xfree (interpreter_p
);
710 interpreter_p
= xstrdup (INTERP_CONSOLE
);
713 annotation_level
= 1;
729 struct cmdarg cmdarg
= { CMDARG_FILE
, optarg
};
731 VEC_safe_push (cmdarg_s
, cmdarg_vec
, &cmdarg
);
736 struct cmdarg cmdarg
= { CMDARG_COMMAND
, optarg
};
738 VEC_safe_push (cmdarg_s
, cmdarg_vec
, &cmdarg
);
743 struct cmdarg cmdarg
= { CMDARG_INIT_FILE
, optarg
};
745 VEC_safe_push (cmdarg_s
, cmdarg_vec
, &cmdarg
);
750 struct cmdarg cmdarg
= { CMDARG_INIT_COMMAND
, optarg
};
752 VEC_safe_push (cmdarg_s
, cmdarg_vec
, &cmdarg
);
756 batch_flag
= batch_silent
= 1;
757 gdb_stdout
= ui_file_new();
760 if (optarg
[0] == '\0')
762 fprintf_unfiltered (gdb_stderr
,
763 _("%s: empty path for"
764 " `--data-directory'\n"),
768 set_gdb_data_directory (optarg
);
769 gdb_datadir_provided
= 1;
774 extern int gdbtk_test (char *);
776 if (!gdbtk_test (optarg
))
778 fprintf_unfiltered (gdb_stderr
,
779 _("%s: unable to load "
780 "tclcommand file \"%s\""),
787 /* Backwards compatibility only. */
791 /* Set the external editor commands when gdb is farming out files
792 to be edited by another program. */
793 extern char *external_editor_command
;
795 external_editor_command
= xstrdup (optarg
);
800 xfree (interpreter_p
);
801 interpreter_p
= xstrdup (optarg
);
804 dirarg
[ndir
++] = optarg
;
808 dirarg
= (char **) xrealloc ((char *) dirarg
,
809 dirsize
* sizeof (*dirarg
));
823 i
= strtol (optarg
, &p
, 0);
824 if (i
== 0 && p
== optarg
)
826 /* Don't use *_filtered or warning() (which relies on
827 current_target) until after initialize_all_files(). */
831 _("warning: could not set baud rate to `%s'.\n"), optarg
);
841 i
= strtol (optarg
, &p
, 0);
842 if (i
== 0 && p
== optarg
)
844 /* Don't use *_filtered or warning() (which relies on
845 current_target) until after initialize_all_files(). */
847 fprintf_unfiltered (gdb_stderr
,
848 _("warning: could not set "
849 "timeout limit to `%s'.\n"), optarg
);
856 fprintf_unfiltered (gdb_stderr
,
857 _("Use `%s --help' for a "
858 "complete list of options.\n"),
868 /* Try to set up an alternate signal stack for SIGSEGV handlers. */
869 setup_alternate_signal_stack ();
871 /* Initialize all files. Give the interpreter a chance to take
872 control of the console via the deprecated_init_ui_hook (). */
873 gdb_init (gdb_program_name
);
875 /* Now that gdb_init has created the initial inferior, we're in
876 position to set args for that inferior. */
879 /* The remaining options are the command-line options for the
880 inferior. The first one is the sym/exec file, and the rest
884 fprintf_unfiltered (gdb_stderr
,
885 _("%s: `--args' specified but "
886 "no program specified\n"),
890 symarg
= argv
[optind
];
891 execarg
= argv
[optind
];
893 set_inferior_args_vector (argc
- optind
, &argv
[optind
]);
897 /* OK, that's all the options. */
899 /* The first argument, if specified, is the name of the
903 symarg
= argv
[optind
];
904 execarg
= argv
[optind
];
908 /* If the user hasn't already specified a PID or the name of a
909 core file, then a second optional argument is allowed. If
910 present, this argument should be interpreted as either a
911 PID or a core file, whichever works. */
912 if (pidarg
== NULL
&& corearg
== NULL
&& optind
< argc
)
914 pid_or_core_arg
= argv
[optind
];
918 /* Any argument left on the command line is unexpected and
919 will be ignored. Inform the user. */
921 fprintf_unfiltered (gdb_stderr
,
922 _("Excess command line "
923 "arguments ignored. (%s%s)\n"),
925 (optind
== argc
- 1) ? "" : " ...");
928 /* Lookup gdbinit files. Note that the gdbinit file name may be
929 overriden during file initialization, so get_init_files should be
930 called after gdb_init. */
931 get_init_files (&system_gdbinit
, &home_gdbinit
, &local_gdbinit
);
933 /* Do these (and anything which might call wrap_here or *_filtered)
934 after initialize_all_files() but before the interpreter has been
935 installed. Otherwize the help/version messages will be eaten by
936 the interpreter's output handler. */
940 print_gdb_version (gdb_stdout
);
942 printf_filtered ("\n");
948 print_gdb_help (gdb_stdout
);
949 fputs_unfiltered ("\n", gdb_stdout
);
953 if (print_configuration
)
955 print_gdb_configuration (gdb_stdout
);
957 printf_filtered ("\n");
961 /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
962 GDB retain the old MI1 interpreter startup behavior. Output the
963 copyright message before the interpreter is installed. That way
964 it isn't encapsulated in MI output. */
965 if (!quiet
&& strcmp (interpreter_p
, INTERP_MI1
) == 0)
967 /* Print all the junk at the top, with trailing "..." if we are
968 about to read a symbol file (possibly slowly). */
969 print_gdb_version (gdb_stdout
);
971 printf_filtered ("..");
973 printf_filtered ("\n");
974 gdb_flush (gdb_stdout
); /* Force to screen during slow
978 /* Install the default UI. All the interpreters should have had a
979 look at things by now. Initialize the default interpreter. */
983 struct interp
*interp
= interp_lookup (interpreter_p
);
986 error (_("Interpreter `%s' unrecognized"), interpreter_p
);
988 if (!interp_set (interp
, 1))
990 fprintf_unfiltered (gdb_stderr
,
991 "Interpreter `%s' failed to initialize.\n",
997 /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
998 GDB retain the old MI1 interpreter startup behavior. Output the
999 copyright message after the interpreter is installed when it is
1000 any sane interpreter. */
1001 if (!quiet
&& !current_interp_named_p (INTERP_MI1
))
1003 /* Print all the junk at the top, with trailing "..." if we are
1004 about to read a symbol file (possibly slowly). */
1005 print_gdb_version (gdb_stdout
);
1007 printf_filtered ("..");
1009 printf_filtered ("\n");
1010 gdb_flush (gdb_stdout
); /* Force to screen during slow
1014 /* Set off error and warning messages with a blank line. */
1015 warning_pre_print
= _("\nwarning: ");
1017 /* Read and execute the system-wide gdbinit file, if it exists.
1018 This is done *before* all the command line arguments are
1019 processed; it sets global parameters, which are independent of
1020 what file you are debugging or what directory you are in. */
1021 if (system_gdbinit
&& !inhibit_gdbinit
)
1022 catch_command_errors_const (source_script
, system_gdbinit
,
1023 0, RETURN_MASK_ALL
);
1025 /* Read and execute $HOME/.gdbinit file, if it exists. This is done
1026 *before* all the command line arguments are processed; it sets
1027 global parameters, which are independent of what file you are
1028 debugging or what directory you are in. */
1030 if (home_gdbinit
&& !inhibit_gdbinit
&& !inhibit_home_gdbinit
)
1031 catch_command_errors_const (source_script
,
1032 home_gdbinit
, 0, RETURN_MASK_ALL
);
1034 /* Process '-ix' and '-iex' options early. */
1035 for (i
= 0; VEC_iterate (cmdarg_s
, cmdarg_vec
, i
, cmdarg_p
); i
++)
1036 switch (cmdarg_p
->type
)
1038 case CMDARG_INIT_FILE
:
1039 catch_command_errors_const (source_script
, cmdarg_p
->string
,
1040 !batch_flag
, RETURN_MASK_ALL
);
1042 case CMDARG_INIT_COMMAND
:
1043 catch_command_errors (execute_command
, cmdarg_p
->string
,
1044 !batch_flag
, RETURN_MASK_ALL
);
1048 /* Now perform all the actions indicated by the arguments. */
1051 catch_command_errors (cd_command
, cdarg
, 0, RETURN_MASK_ALL
);
1054 for (i
= 0; i
< ndir
; i
++)
1055 catch_command_errors (directory_switch
, dirarg
[i
], 0, RETURN_MASK_ALL
);
1058 /* Skip auto-loading section-specified scripts until we've sourced
1059 local_gdbinit (which is often used to augment the source search
1061 save_auto_load
= global_auto_load
;
1062 global_auto_load
= 0;
1066 && strcmp (execarg
, symarg
) == 0)
1068 /* The exec file and the symbol-file are the same. If we can't
1069 open it, better only print one error message.
1070 catch_command_errors returns non-zero on success! */
1071 if (catch_command_errors_const (exec_file_attach
, execarg
,
1072 !batch_flag
, RETURN_MASK_ALL
))
1073 catch_command_errors_const (symbol_file_add_main
, symarg
,
1074 !batch_flag
, RETURN_MASK_ALL
);
1078 if (execarg
!= NULL
)
1079 catch_command_errors_const (exec_file_attach
, execarg
,
1080 !batch_flag
, RETURN_MASK_ALL
);
1082 catch_command_errors_const (symbol_file_add_main
, symarg
,
1083 !batch_flag
, RETURN_MASK_ALL
);
1086 if (corearg
&& pidarg
)
1087 error (_("Can't attach to process and specify "
1088 "a core file at the same time."));
1090 if (corearg
!= NULL
)
1091 catch_command_errors (core_file_command
, corearg
,
1092 !batch_flag
, RETURN_MASK_ALL
);
1093 else if (pidarg
!= NULL
)
1094 catch_command_errors (attach_command
, pidarg
,
1095 !batch_flag
, RETURN_MASK_ALL
);
1096 else if (pid_or_core_arg
)
1098 /* The user specified 'gdb program pid' or gdb program core'.
1099 If pid_or_core_arg's first character is a digit, try attach
1100 first and then corefile. Otherwise try just corefile. */
1102 if (isdigit (pid_or_core_arg
[0]))
1104 if (catch_command_errors (attach_command
, pid_or_core_arg
,
1105 !batch_flag
, RETURN_MASK_ALL
) == 0)
1106 catch_command_errors (core_file_command
, pid_or_core_arg
,
1107 !batch_flag
, RETURN_MASK_ALL
);
1109 else /* Can't be a pid, better be a corefile. */
1110 catch_command_errors (core_file_command
, pid_or_core_arg
,
1111 !batch_flag
, RETURN_MASK_ALL
);
1115 set_inferior_io_terminal (ttyarg
);
1117 /* Error messages should no longer be distinguished with extra output. */
1118 warning_pre_print
= _("warning: ");
1120 /* Read the .gdbinit file in the current directory, *if* it isn't
1121 the same as the $HOME/.gdbinit file (it should exist, also). */
1124 auto_load_local_gdbinit_pathname
= gdb_realpath (local_gdbinit
);
1126 if (!inhibit_gdbinit
&& auto_load_local_gdbinit
1127 && file_is_auto_load_safe (local_gdbinit
,
1128 _("auto-load: Loading .gdbinit "
1132 auto_load_local_gdbinit_loaded
= 1;
1134 catch_command_errors_const (source_script
, local_gdbinit
, 0,
1139 /* Now that all .gdbinit's have been read and all -d options have been
1140 processed, we can read any scripts mentioned in SYMARG.
1141 We wait until now because it is common to add to the source search
1142 path in local_gdbinit. */
1143 global_auto_load
= save_auto_load
;
1144 ALL_OBJFILES (objfile
)
1145 load_auto_scripts_for_objfile (objfile
);
1147 /* Process '-x' and '-ex' options. */
1148 for (i
= 0; VEC_iterate (cmdarg_s
, cmdarg_vec
, i
, cmdarg_p
); i
++)
1149 switch (cmdarg_p
->type
)
1152 catch_command_errors_const (source_script
, cmdarg_p
->string
,
1153 !batch_flag
, RETURN_MASK_ALL
);
1155 case CMDARG_COMMAND
:
1156 catch_command_errors (execute_command
, cmdarg_p
->string
,
1157 !batch_flag
, RETURN_MASK_ALL
);
1161 /* Read in the old history after all the command files have been
1167 /* We have hit the end of the batch file. */
1168 quit_force (NULL
, 0);
1171 /* Show time and/or space usage. */
1172 do_cleanups (pre_stat_chain
);
1174 /* NOTE: cagney/1999-11-07: There is probably no reason for not
1175 moving this loop and the code found in captured_command_loop()
1176 into the command_loop() proper. The main thing holding back that
1177 change - SET_TOP_LEVEL() - has been eliminated. */
1180 catch_errors (captured_command_loop
, 0, "", RETURN_MASK_ALL
);
1182 /* No exit -- exit is through quit_command. */
1186 gdb_main (struct captured_main_args
*args
)
1188 catch_errors (captured_main
, args
, "", RETURN_MASK_ALL
);
1189 /* The only way to end up here is by an error (normal exit is
1190 handled by quit_force()), hence always return an error status. */
1195 /* Don't use *_filtered for printing help. We don't want to prompt
1196 for continue no matter how small the screen or how much we're going
1200 print_gdb_help (struct ui_file
*stream
)
1202 const char *system_gdbinit
;
1203 const char *home_gdbinit
;
1204 const char *local_gdbinit
;
1206 get_init_files (&system_gdbinit
, &home_gdbinit
, &local_gdbinit
);
1208 /* Note: The options in the list below are only approximately sorted
1209 in the alphabetical order, so as to group closely related options
1211 fputs_unfiltered (_("\
1212 This is the GNU debugger. Usage:\n\n\
1213 gdb [options] [executable-file [core-file or process-id]]\n\
1214 gdb [options] --args executable-file [inferior-arguments ...]\n\n\
1216 fputs_unfiltered (_("\
1217 Selection of debuggee and its files:\n\n\
1218 --args Arguments after executable-file are passed to inferior\n\
1219 --core=COREFILE Analyze the core dump COREFILE.\n\
1220 --exec=EXECFILE Use EXECFILE as the executable.\n\
1221 --pid=PID Attach to running process PID.\n\
1222 --directory=DIR Search for source files in DIR.\n\
1223 --se=FILE Use FILE as symbol file and executable file.\n\
1224 --symbols=SYMFILE Read symbols from SYMFILE.\n\
1225 --readnow Fully read symbol files on first access.\n\
1226 --write Set writing into executable and core files.\n\n\
1228 fputs_unfiltered (_("\
1229 Initial commands and command files:\n\n\
1230 --command=FILE, -x Execute GDB commands from FILE.\n\
1231 --init-command=FILE, -ix\n\
1232 Like -x but execute commands before loading inferior.\n\
1233 --eval-command=COMMAND, -ex\n\
1234 Execute a single GDB command.\n\
1235 May be used multiple times and in conjunction\n\
1237 --init-eval-command=COMMAND, -iex\n\
1238 Like -ex but before loading inferior.\n\
1239 --nh Do not read ~/.gdbinit.\n\
1240 --nx Do not read any .gdbinit files in any directory.\n\n\
1242 fputs_unfiltered (_("\
1243 Output and user interface control:\n\n\
1244 --fullname Output information used by emacs-GDB interface.\n\
1245 --interpreter=INTERP\n\
1246 Select a specific interpreter / user interface\n\
1247 --tty=TTY Use TTY for input/output by the program being debugged.\n\
1248 -w Use the GUI interface.\n\
1249 --nw Do not use the GUI interface.\n\
1252 fputs_unfiltered (_("\
1253 --tui Use a terminal user interface.\n\
1256 fputs_unfiltered (_("\
1257 --dbx DBX compatibility mode.\n\
1258 --xdb XDB compatibility mode.\n\
1259 -q, --quiet, --silent\n\
1260 Do not print version number on startup.\n\n\
1262 fputs_unfiltered (_("\
1263 Operating modes:\n\n\
1264 --batch Exit after processing options.\n\
1265 --batch-silent Like --batch, but suppress all gdb stdout output.\n\
1266 --return-child-result\n\
1267 GDB exit code will be the child's exit code.\n\
1268 --configuration Print details about GDB configuration and then exit.\n\
1269 --help Print this message and then exit.\n\
1270 --version Print version information and then exit.\n\n\
1271 Remote debugging options:\n\n\
1272 -b BAUDRATE Set serial port baud rate used for remote debugging.\n\
1273 -l TIMEOUT Set timeout in seconds for remote debugging.\n\n\
1275 --cd=DIR Change current directory to DIR.\n\
1276 --data-directory=DIR, -D\n\
1277 Set GDB's data-directory to DIR.\n\
1279 fputs_unfiltered (_("\n\
1280 At startup, GDB reads the following init files and executes their commands:\n\
1283 fprintf_unfiltered (stream
, _("\
1284 * system-wide init file: %s\n\
1285 "), system_gdbinit
);
1287 fprintf_unfiltered (stream
, _("\
1288 * user-specific init file: %s\n\
1291 fprintf_unfiltered (stream
, _("\
1292 * local init file (see also 'set auto-load local-gdbinit'): ./%s\n\
1294 fputs_unfiltered (_("\n\
1295 For more information, type \"help\" from within GDB, or consult the\n\
1296 GDB manual (available as on-line info or a printed manual).\n\
1298 if (REPORT_BUGS_TO
[0] && stream
== gdb_stdout
)
1299 fprintf_unfiltered (stream
, _("\
1300 Report bugs to \"%s\".\n\
1301 "), REPORT_BUGS_TO
);