1 /* Top level stuff for GDB, the GNU debugger.
3 Copyright (C) 1986-2013 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>
34 #include "gdb_string.h"
35 #include "event-loop.h"
41 #include "cli/cli-cmds.h"
42 #include "python/python.h"
44 #include "auto-load.h"
46 /* The selected interpreter. This will be used as a set command
47 variable, so it should always be malloc'ed - since
48 do_setshow_command will free it. */
51 /* Whether xdb commands will be handled. */
54 /* Whether dbx commands will be handled. */
57 /* System root path, used to find libraries etc. */
58 char *gdb_sysroot = 0;
60 /* GDB datadir, used to store data files. */
61 char *gdb_datadir = 0;
63 /* Non-zero if GDB_DATADIR was provided on the command line.
64 This doesn't track whether data-directory is set later from the
65 command line, but we don't reread system.gdbinit when that happens. */
66 static int gdb_datadir_provided = 0;
68 /* If gdb was configured with --with-python=/path,
69 the possibly relocated path to python's lib directory. */
70 char *python_libdir = 0;
72 struct ui_file *gdb_stdout;
73 struct ui_file *gdb_stderr;
74 struct ui_file *gdb_stdlog;
75 struct ui_file *gdb_stdin;
76 /* Target IO streams. */
77 struct ui_file *gdb_stdtargin;
78 struct ui_file *gdb_stdtarg;
79 struct ui_file *gdb_stdtargerr;
81 /* True if --batch or --batch-silent was seen. */
84 /* Support for the --batch-silent option. */
87 /* Support for --return-child-result option.
88 Set the default to -1 to return error in the case
89 that the program does not run or does not complete. */
90 int return_child_result = 0;
91 int return_child_result_value = -1;
94 /* GDB as it has been invoked from the command line (i.e. argv[0]). */
95 static char *gdb_program_name;
97 static void print_gdb_help (struct ui_file *);
99 /* Relocate a file or directory. PROGNAME is the name by which gdb
100 was invoked (i.e., argv[0]). INITIAL is the default value for the
101 file or directory. FLAG is true if the value is relocatable, false
102 otherwise. Returns a newly allocated string; this may return NULL
103 under the same conditions as make_relative_prefix. */
106 relocate_path (const char *progname, const char *initial, int flag)
109 return make_relative_prefix (progname, BINDIR, initial);
110 return xstrdup (initial);
113 /* Like relocate_path, but specifically checks for a directory.
114 INITIAL is relocated according to the rules of relocate_path. If
115 the result is a directory, it is used; otherwise, INITIAL is used.
116 The chosen directory is then canonicalized using lrealpath. This
117 function always returns a newly-allocated string. */
120 relocate_gdb_directory (const char *initial, int flag)
124 dir = relocate_path (gdb_program_name, initial, flag);
129 if (stat (dir, &s) != 0 || !S_ISDIR (s.st_mode))
136 dir = xstrdup (initial);
138 /* Canonicalize the directory. */
141 char *canon_sysroot = lrealpath (dir);
153 /* Compute the locations of init files that GDB should source and
154 return them in SYSTEM_GDBINIT, HOME_GDBINIT, LOCAL_GDBINIT. If
155 there is no system gdbinit (resp. home gdbinit and local gdbinit)
156 to be loaded, then SYSTEM_GDBINIT (resp. HOME_GDBINIT and
157 LOCAL_GDBINIT) is set to NULL. */
159 get_init_files (char **system_gdbinit,
161 char **local_gdbinit)
163 static char *sysgdbinit = NULL;
164 static char *homeinit = NULL;
165 static char *localinit = NULL;
166 static int initialized = 0;
170 struct stat homebuf, cwdbuf, s;
173 if (SYSTEM_GDBINIT[0])
175 int datadir_len = strlen (GDB_DATADIR);
176 int sys_gdbinit_len = strlen (SYSTEM_GDBINIT);
177 char *relocated_sysgdbinit;
179 /* If SYSTEM_GDBINIT lives in data-directory, and data-directory
180 has been provided, search for SYSTEM_GDBINIT there. */
181 if (gdb_datadir_provided
182 && datadir_len < sys_gdbinit_len
183 && strncmp (SYSTEM_GDBINIT, GDB_DATADIR, datadir_len) == 0
184 && strchr (SLASH_STRING, SYSTEM_GDBINIT[datadir_len]) != NULL)
186 /* Append the part of SYSTEM_GDBINIT that follows GDB_DATADIR
188 char *tmp_sys_gdbinit = xstrdup (SYSTEM_GDBINIT + datadir_len);
191 for (p = tmp_sys_gdbinit; strchr (SLASH_STRING, *p); ++p)
193 relocated_sysgdbinit = concat (gdb_datadir, SLASH_STRING, p,
195 xfree (tmp_sys_gdbinit);
199 relocated_sysgdbinit = relocate_path (gdb_program_name,
201 SYSTEM_GDBINIT_RELOCATABLE);
203 if (relocated_sysgdbinit && stat (relocated_sysgdbinit, &s) == 0)
204 sysgdbinit = relocated_sysgdbinit;
206 xfree (relocated_sysgdbinit);
209 homedir = getenv ("HOME");
211 /* If the .gdbinit file in the current directory is the same as
212 the $HOME/.gdbinit file, it should not be sourced. homebuf
213 and cwdbuf are used in that purpose. Make sure that the stats
214 are zero in case one of them fails (this guarantees that they
215 won't match if either exists). */
217 memset (&homebuf, 0, sizeof (struct stat));
218 memset (&cwdbuf, 0, sizeof (struct stat));
222 homeinit = xstrprintf ("%s/%s", homedir, gdbinit);
223 if (stat (homeinit, &homebuf) != 0)
230 if (stat (gdbinit, &cwdbuf) == 0)
233 || memcmp ((char *) &homebuf, (char *) &cwdbuf,
234 sizeof (struct stat)))
241 *system_gdbinit = sysgdbinit;
242 *home_gdbinit = homeinit;
243 *local_gdbinit = localinit;
246 /* Call command_loop. If it happens to return, pass that through as a
247 non-zero return status. */
250 captured_command_loop (void *data)
252 /* Top-level execution commands can be run on the background from
254 interpreter_async = 1;
256 current_interp_command_loop ();
257 /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
258 would clean things up (restoring the cleanup chain) to the state
259 they were just prior to the call. Technically, this means that
260 the do_cleanups() below is redundant. Unfortunately, many FUNCs
261 are not that well behaved. do_cleanups should either be replaced
262 with a do_cleanups call (to cover the problem) or an assertion
263 check to detect bad FUNCs code. */
264 do_cleanups (all_cleanups ());
265 /* If the command_loop returned, normally (rather than threw an
266 error) we try to quit. If the quit is aborted, catch_errors()
267 which called this catch the signal and restart the command
269 quit_command (NULL, instream == stdin);
273 /* Arguments of --command option and its counterpart. */
274 typedef struct cmdarg {
275 /* Type of this option. */
277 /* Option type -x. */
280 /* Option type -ex. */
283 /* Option type -ix. */
286 /* Option type -iex. */
290 /* Value of this option - filename or the GDB command itself. String memory
291 is not owned by this structure despite it is 'const'. */
295 /* Define type VEC (cmdarg_s). */
296 DEF_VEC_O (cmdarg_s);
299 captured_main (void *data)
301 struct captured_main_args *context = data;
302 int argc = context->argc;
303 char **argv = context->argv;
304 static int quiet = 0;
305 static int set_args = 0;
306 static int inhibit_home_gdbinit = 0;
308 /* Pointers to various arguments from command line. */
310 char *execarg = NULL;
312 char *corearg = NULL;
313 char *pid_or_core_arg = NULL;
317 /* These are static so that we can take their address in an
319 static int print_help;
320 static int print_version;
322 /* Pointers to all arguments of --command option. */
323 VEC (cmdarg_s) *cmdarg_vec = NULL;
324 struct cmdarg *cmdarg_p;
326 /* Indices of all arguments of --directory option. */
328 /* Allocated size. */
330 /* Number of elements used. */
333 /* gdb init files. */
334 char *system_gdbinit;
340 struct objfile *objfile;
342 struct cleanup *pre_stat_chain;
345 /* Set this before calling make_command_stats_cleanup. */
346 lim_at_start = (char *) sbrk (0);
349 pre_stat_chain = make_command_stats_cleanup (0);
351 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
352 setlocale (LC_MESSAGES, "");
354 #if defined (HAVE_SETLOCALE)
355 setlocale (LC_CTYPE, "");
357 bindtextdomain (PACKAGE, LOCALEDIR);
358 textdomain (PACKAGE);
360 make_cleanup (VEC_cleanup (cmdarg_s), &cmdarg_vec);
362 dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
366 saved_command_line = (char *) xmalloc (saved_command_line_size);
367 saved_command_line[0] = '\0';
370 gdb_stdout = stdio_fileopen (stdout);
371 gdb_stderr = stdio_fileopen (stderr);
372 gdb_stdlog = gdb_stderr; /* for moment */
373 gdb_stdtarg = gdb_stderr; /* for moment */
374 gdb_stdin = stdio_fileopen (stdin);
375 gdb_stdtargerr = gdb_stderr; /* for moment */
376 gdb_stdtargin = gdb_stdin; /* for moment */
378 gdb_program_name = xstrdup (argv[0]);
380 if (! getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)))
381 /* Don't use *_filtered or warning() (which relies on
382 current_target) until after initialize_all_files(). */
383 fprintf_unfiltered (gdb_stderr,
384 _("%s: warning: error finding "
385 "working directory: %s\n"),
386 argv[0], safe_strerror (errno));
388 current_directory = gdb_dirbuf;
390 /* Set the sysroot path. */
391 gdb_sysroot = relocate_gdb_directory (TARGET_SYSTEM_ROOT,
392 TARGET_SYSTEM_ROOT_RELOCATABLE);
394 debug_file_directory = relocate_gdb_directory (DEBUGDIR,
395 DEBUGDIR_RELOCATABLE);
397 gdb_datadir = relocate_gdb_directory (GDB_DATADIR,
398 GDB_DATADIR_RELOCATABLE);
400 #ifdef WITH_PYTHON_PATH
402 /* For later use in helping Python find itself. */
403 char *tmp = concat (WITH_PYTHON_PATH, SLASH_STRING, "lib", NULL);
405 python_libdir = relocate_gdb_directory (tmp, PYTHON_PATH_RELOCATABLE);
411 add_substitute_path_rule (RELOC_SRCDIR,
412 make_relative_prefix (argv[0], BINDIR,
416 /* There will always be an interpreter. Either the one passed into
417 this captured main, or one specified by the user at start up, or
418 the console. Initialize the interpreter to the one requested by
420 interpreter_p = xstrdup (context->interpreter_p);
422 /* Parse arguments and options. */
425 /* When var field is 0, use flag field to record the equivalent
426 short option (or arbitrary numbers starting at 10 for those
427 with no equivalent). */
439 static struct option long_options[] =
441 {"tui", no_argument, 0, OPT_TUI},
442 {"xdb", no_argument, &xdb_commands, 1},
443 {"dbx", no_argument, &dbx_commands, 1},
444 {"readnow", no_argument, &readnow_symbol_files, 1},
445 {"r", no_argument, &readnow_symbol_files, 1},
446 {"quiet", no_argument, &quiet, 1},
447 {"q", no_argument, &quiet, 1},
448 {"silent", no_argument, &quiet, 1},
449 {"nh", no_argument, &inhibit_home_gdbinit, 1},
450 {"nx", no_argument, &inhibit_gdbinit, 1},
451 {"n", no_argument, &inhibit_gdbinit, 1},
452 {"batch-silent", no_argument, 0, 'B'},
453 {"batch", no_argument, &batch_flag, 1},
454 {"epoch", no_argument, &epoch_interface, 1},
456 /* This is a synonym for "--annotate=1". --annotate is now
457 preferred, but keep this here for a long time because people
458 will be running emacses which use --fullname. */
459 {"fullname", no_argument, 0, 'f'},
460 {"f", no_argument, 0, 'f'},
462 {"annotate", required_argument, 0, OPT_ANNOTATE},
463 {"help", no_argument, &print_help, 1},
464 {"se", required_argument, 0, OPT_SE},
465 {"symbols", required_argument, 0, 's'},
466 {"s", required_argument, 0, 's'},
467 {"exec", required_argument, 0, 'e'},
468 {"e", required_argument, 0, 'e'},
469 {"core", required_argument, 0, 'c'},
470 {"c", required_argument, 0, 'c'},
471 {"pid", required_argument, 0, 'p'},
472 {"p", required_argument, 0, 'p'},
473 {"command", required_argument, 0, 'x'},
474 {"eval-command", required_argument, 0, 'X'},
475 {"version", no_argument, &print_version, 1},
476 {"x", required_argument, 0, 'x'},
477 {"ex", required_argument, 0, 'X'},
478 {"init-command", required_argument, 0, OPT_IX},
479 {"init-eval-command", required_argument, 0, OPT_IEX},
480 {"ix", required_argument, 0, OPT_IX},
481 {"iex", required_argument, 0, OPT_IEX},
483 {"tclcommand", required_argument, 0, 'z'},
484 {"enable-external-editor", no_argument, 0, 'y'},
485 {"editor-command", required_argument, 0, 'w'},
487 {"ui", required_argument, 0, 'i'},
488 {"interpreter", required_argument, 0, 'i'},
489 {"i", required_argument, 0, 'i'},
490 {"directory", required_argument, 0, 'd'},
491 {"d", required_argument, 0, 'd'},
492 {"data-directory", required_argument, 0, 'D'},
493 {"cd", required_argument, 0, OPT_CD},
494 {"tty", required_argument, 0, 't'},
495 {"baud", required_argument, 0, 'b'},
496 {"b", required_argument, 0, 'b'},
497 {"nw", no_argument, NULL, OPT_NOWINDOWS},
498 {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
499 {"w", no_argument, NULL, OPT_WINDOWS},
500 {"windows", no_argument, NULL, OPT_WINDOWS},
501 {"statistics", no_argument, 0, OPT_STATISTICS},
502 {"write", no_argument, &write_files, 1},
503 {"args", no_argument, &set_args, 1},
504 {"l", required_argument, 0, 'l'},
505 {"return-child-result", no_argument, &return_child_result, 1},
506 {0, no_argument, 0, 0}
513 c = getopt_long_only (argc, argv, "",
514 long_options, &option_index);
515 if (c == EOF || set_args)
518 /* Long option that takes an argument. */
519 if (c == 0 && long_options[option_index].flag == 0)
520 c = long_options[option_index].val;
525 /* Long option that just sets a flag. */
535 /* FIXME: what if the syntax is wrong (e.g. not digits)? */
536 annotation_level = atoi (optarg);
539 /* Enable the display of both time and space usage. */
540 set_display_time (1);
541 set_display_space (1);
544 /* --tui is equivalent to -i=tui. */
546 xfree (interpreter_p);
547 interpreter_p = xstrdup (INTERP_TUI);
549 fprintf_unfiltered (gdb_stderr,
550 _("%s: TUI mode is not supported\n"),
556 /* FIXME: cagney/2003-03-01: Not sure if this option is
557 actually useful, and if it is, what it should do. */
559 /* --windows is equivalent to -i=insight. */
560 xfree (interpreter_p);
561 interpreter_p = xstrdup (INTERP_INSIGHT);
566 /* -nw is equivalent to -i=console. */
567 xfree (interpreter_p);
568 interpreter_p = xstrdup (INTERP_CONSOLE);
572 annotation_level = 1;
573 /* We have probably been invoked from emacs. Disable
591 struct cmdarg cmdarg = { CMDARG_FILE, optarg };
593 VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
598 struct cmdarg cmdarg = { CMDARG_COMMAND, optarg };
600 VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
605 struct cmdarg cmdarg = { CMDARG_INIT_FILE, optarg };
607 VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
612 struct cmdarg cmdarg = { CMDARG_INIT_COMMAND, optarg };
614 VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
618 batch_flag = batch_silent = 1;
619 gdb_stdout = ui_file_new();
623 gdb_datadir = xstrdup (optarg);
624 gdb_datadir_provided = 1;
629 extern int gdbtk_test (char *);
631 if (!gdbtk_test (optarg))
633 fprintf_unfiltered (gdb_stderr,
634 _("%s: unable to load "
635 "tclcommand file \"%s\""),
642 /* Backwards compatibility only. */
646 /* Set the external editor commands when gdb is farming out files
647 to be edited by another program. */
648 extern char *external_editor_command;
650 external_editor_command = xstrdup (optarg);
655 xfree (interpreter_p);
656 interpreter_p = xstrdup (optarg);
659 dirarg[ndir++] = optarg;
663 dirarg = (char **) xrealloc ((char *) dirarg,
664 dirsize * sizeof (*dirarg));
678 i = strtol (optarg, &p, 0);
679 if (i == 0 && p == optarg)
681 /* Don't use *_filtered or warning() (which relies on
682 current_target) until after initialize_all_files(). */
686 _("warning: could not set baud rate to `%s'.\n"), optarg);
696 i = strtol (optarg, &p, 0);
697 if (i == 0 && p == optarg)
699 /* Don't use *_filtered or warning() (which relies on
700 current_target) until after initialize_all_files(). */
702 fprintf_unfiltered (gdb_stderr,
703 _("warning: could not set "
704 "timeout limit to `%s'.\n"), optarg);
711 fprintf_unfiltered (gdb_stderr,
712 _("Use `%s --help' for a "
713 "complete list of options.\n"),
719 /* If --help or --version, disable window interface. */
720 if (print_help || print_version)
729 /* Initialize all files. Give the interpreter a chance to take
730 control of the console via the deprecated_init_ui_hook (). */
733 /* Now that gdb_init has created the initial inferior, we're in
734 position to set args for that inferior. */
737 /* The remaining options are the command-line options for the
738 inferior. The first one is the sym/exec file, and the rest
742 fprintf_unfiltered (gdb_stderr,
743 _("%s: `--args' specified but "
744 "no program specified\n"),
748 symarg = argv[optind];
749 execarg = argv[optind];
751 set_inferior_args_vector (argc - optind, &argv[optind]);
755 /* OK, that's all the options. */
757 /* The first argument, if specified, is the name of the
761 symarg = argv[optind];
762 execarg = argv[optind];
766 /* If the user hasn't already specified a PID or the name of a
767 core file, then a second optional argument is allowed. If
768 present, this argument should be interpreted as either a
769 PID or a core file, whichever works. */
770 if (pidarg == NULL && corearg == NULL && optind < argc)
772 pid_or_core_arg = argv[optind];
776 /* Any argument left on the command line is unexpected and
777 will be ignored. Inform the user. */
779 fprintf_unfiltered (gdb_stderr,
780 _("Excess command line "
781 "arguments ignored. (%s%s)\n"),
783 (optind == argc - 1) ? "" : " ...");
786 /* Lookup gdbinit files. Note that the gdbinit file name may be
787 overriden during file initialization, so get_init_files should be
788 called after gdb_init. */
789 get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
791 /* Do these (and anything which might call wrap_here or *_filtered)
792 after initialize_all_files() but before the interpreter has been
793 installed. Otherwize the help/version messages will be eaten by
794 the interpreter's output handler. */
798 print_gdb_version (gdb_stdout);
800 printf_filtered ("\n");
806 print_gdb_help (gdb_stdout);
807 fputs_unfiltered ("\n", gdb_stdout);
811 /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
812 GDB retain the old MI1 interpreter startup behavior. Output the
813 copyright message before the interpreter is installed. That way
814 it isn't encapsulated in MI output. */
815 if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
817 /* Print all the junk at the top, with trailing "..." if we are
818 about to read a symbol file (possibly slowly). */
819 print_gdb_version (gdb_stdout);
821 printf_filtered ("..");
823 printf_filtered ("\n");
824 gdb_flush (gdb_stdout); /* Force to screen during slow
828 /* Install the default UI. All the interpreters should have had a
829 look at things by now. Initialize the default interpreter. */
833 struct interp *interp = interp_lookup (interpreter_p);
836 error (_("Interpreter `%s' unrecognized"), interpreter_p);
838 if (!interp_set (interp, 1))
840 fprintf_unfiltered (gdb_stderr,
841 "Interpreter `%s' failed to initialize.\n",
847 /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
848 GDB retain the old MI1 interpreter startup behavior. Output the
849 copyright message after the interpreter is installed when it is
850 any sane interpreter. */
851 if (!quiet && !current_interp_named_p (INTERP_MI1))
853 /* Print all the junk at the top, with trailing "..." if we are
854 about to read a symbol file (possibly slowly). */
855 print_gdb_version (gdb_stdout);
857 printf_filtered ("..");
859 printf_filtered ("\n");
860 gdb_flush (gdb_stdout); /* Force to screen during slow
864 /* Set off error and warning messages with a blank line. */
865 error_pre_print = "\n";
866 quit_pre_print = error_pre_print;
867 warning_pre_print = _("\nwarning: ");
869 /* Read and execute the system-wide gdbinit file, if it exists.
870 This is done *before* all the command line arguments are
871 processed; it sets global parameters, which are independent of
872 what file you are debugging or what directory you are in. */
873 if (system_gdbinit && !inhibit_gdbinit)
874 catch_command_errors (source_script, system_gdbinit, 0, RETURN_MASK_ALL);
876 /* Read and execute $HOME/.gdbinit file, if it exists. This is done
877 *before* all the command line arguments are processed; it sets
878 global parameters, which are independent of what file you are
879 debugging or what directory you are in. */
881 if (home_gdbinit && !inhibit_gdbinit && !inhibit_home_gdbinit)
882 catch_command_errors (source_script, home_gdbinit, 0, RETURN_MASK_ALL);
884 /* Process '-ix' and '-iex' options early. */
885 for (i = 0; VEC_iterate (cmdarg_s, cmdarg_vec, i, cmdarg_p); i++)
886 switch (cmdarg_p->type)
888 case CMDARG_INIT_FILE:
889 catch_command_errors (source_script, cmdarg_p->string,
890 !batch_flag, RETURN_MASK_ALL);
892 case CMDARG_INIT_COMMAND:
893 catch_command_errors (execute_command, cmdarg_p->string,
894 !batch_flag, RETURN_MASK_ALL);
898 /* Now perform all the actions indicated by the arguments. */
901 catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
904 for (i = 0; i < ndir; i++)
905 catch_command_errors (directory_switch, dirarg[i], 0, RETURN_MASK_ALL);
908 /* Skip auto-loading section-specified scripts until we've sourced
909 local_gdbinit (which is often used to augment the source search
911 save_auto_load = global_auto_load;
912 global_auto_load = 0;
916 && strcmp (execarg, symarg) == 0)
918 /* The exec file and the symbol-file are the same. If we can't
919 open it, better only print one error message.
920 catch_command_errors returns non-zero on success! */
921 if (catch_command_errors (exec_file_attach, execarg,
922 !batch_flag, RETURN_MASK_ALL))
923 catch_command_errors (symbol_file_add_main, symarg,
924 !batch_flag, RETURN_MASK_ALL);
929 catch_command_errors (exec_file_attach, execarg,
930 !batch_flag, RETURN_MASK_ALL);
932 catch_command_errors (symbol_file_add_main, symarg,
933 !batch_flag, RETURN_MASK_ALL);
936 if (corearg && pidarg)
937 error (_("Can't attach to process and specify "
938 "a core file at the same time."));
941 catch_command_errors (core_file_command, corearg,
942 !batch_flag, RETURN_MASK_ALL);
943 else if (pidarg != NULL)
944 catch_command_errors (attach_command, pidarg,
945 !batch_flag, RETURN_MASK_ALL);
946 else if (pid_or_core_arg)
948 /* The user specified 'gdb program pid' or gdb program core'.
949 If pid_or_core_arg's first character is a digit, try attach
950 first and then corefile. Otherwise try just corefile. */
952 if (isdigit (pid_or_core_arg[0]))
954 if (catch_command_errors (attach_command, pid_or_core_arg,
955 !batch_flag, RETURN_MASK_ALL) == 0)
956 catch_command_errors (core_file_command, pid_or_core_arg,
957 !batch_flag, RETURN_MASK_ALL);
959 else /* Can't be a pid, better be a corefile. */
960 catch_command_errors (core_file_command, pid_or_core_arg,
961 !batch_flag, RETURN_MASK_ALL);
965 set_inferior_io_terminal (ttyarg);
967 /* Error messages should no longer be distinguished with extra output. */
968 error_pre_print = NULL;
969 quit_pre_print = NULL;
970 warning_pre_print = _("warning: ");
972 /* Read the .gdbinit file in the current directory, *if* it isn't
973 the same as the $HOME/.gdbinit file (it should exist, also). */
976 auto_load_local_gdbinit_pathname = gdb_realpath (local_gdbinit);
978 if (!inhibit_gdbinit && auto_load_local_gdbinit
979 && file_is_auto_load_safe (local_gdbinit,
980 _("auto-load: Loading .gdbinit "
984 auto_load_local_gdbinit_loaded = 1;
986 catch_command_errors (source_script, local_gdbinit, 0,
991 /* Now that all .gdbinit's have been read and all -d options have been
992 processed, we can read any scripts mentioned in SYMARG.
993 We wait until now because it is common to add to the source search
994 path in local_gdbinit. */
995 global_auto_load = save_auto_load;
996 ALL_OBJFILES (objfile)
997 load_auto_scripts_for_objfile (objfile);
999 /* Process '-x' and '-ex' options. */
1000 for (i = 0; VEC_iterate (cmdarg_s, cmdarg_vec, i, cmdarg_p); i++)
1001 switch (cmdarg_p->type)
1004 catch_command_errors (source_script, cmdarg_p->string,
1005 !batch_flag, RETURN_MASK_ALL);
1007 case CMDARG_COMMAND:
1008 catch_command_errors (execute_command, cmdarg_p->string,
1009 !batch_flag, RETURN_MASK_ALL);
1013 /* Read in the old history after all the command files have been
1019 /* We have hit the end of the batch file. */
1020 quit_force (NULL, 0);
1023 /* Show time and/or space usage. */
1024 do_cleanups (pre_stat_chain);
1026 /* NOTE: cagney/1999-11-07: There is probably no reason for not
1027 moving this loop and the code found in captured_command_loop()
1028 into the command_loop() proper. The main thing holding back that
1029 change - SET_TOP_LEVEL() - has been eliminated. */
1032 catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
1034 /* No exit -- exit is through quit_command. */
1038 gdb_main (struct captured_main_args *args)
1040 use_windows = args->use_windows;
1041 catch_errors (captured_main, args, "", RETURN_MASK_ALL);
1042 /* The only way to end up here is by an error (normal exit is
1043 handled by quit_force()), hence always return an error status. */
1048 /* Don't use *_filtered for printing help. We don't want to prompt
1049 for continue no matter how small the screen or how much we're going
1053 print_gdb_help (struct ui_file *stream)
1055 char *system_gdbinit;
1057 char *local_gdbinit;
1059 get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
1061 fputs_unfiltered (_("\
1062 This is the GNU debugger. Usage:\n\n\
1063 gdb [options] [executable-file [core-file or process-id]]\n\
1064 gdb [options] --args executable-file [inferior-arguments ...]\n\n\
1067 fputs_unfiltered (_("\
1068 --args Arguments after executable-file are passed to inferior\n\
1070 fputs_unfiltered (_("\
1071 -b BAUDRATE Set serial port baud rate used for remote debugging.\n\
1072 --batch Exit after processing options.\n\
1073 --batch-silent As for --batch, but suppress all gdb stdout output.\n\
1074 --return-child-result\n\
1075 GDB exit code will be the child's exit code.\n\
1076 --cd=DIR Change current directory to DIR.\n\
1077 --command=FILE, -x Execute GDB commands from FILE.\n\
1078 --eval-command=COMMAND, -ex\n\
1079 Execute a single GDB command.\n\
1080 May be used multiple times and in conjunction\n\
1082 --init-command=FILE, -ix Like -x but execute it before loading inferior.\n\
1083 --init-eval-command=COMMAND, -iex Like -ex but before loading inferior.\n\
1084 --core=COREFILE Analyze the core dump COREFILE.\n\
1085 --pid=PID Attach to running process PID.\n\
1087 fputs_unfiltered (_("\
1088 --dbx DBX compatibility mode.\n\
1089 --directory=DIR Search for source files in DIR.\n\
1090 --epoch Output information used by epoch emacs-GDB interface.\n\
1091 --exec=EXECFILE Use EXECFILE as the executable.\n\
1092 --fullname Output information used by emacs-GDB interface.\n\
1093 --help Print this message.\n\
1095 fputs_unfiltered (_("\
1096 --interpreter=INTERP\n\
1097 Select a specific interpreter / user interface\n\
1099 fputs_unfiltered (_("\
1100 -l TIMEOUT Set timeout in seconds for remote debugging.\n\
1101 --nw Do not use a window interface.\n\
1102 --nx Do not read any "), stream);
1103 fputs_unfiltered (gdbinit, stream);
1104 fputs_unfiltered (_(" files.\n\
1105 --nh Do not read "), stream);
1106 fputs_unfiltered (gdbinit, stream);
1107 fputs_unfiltered (_(" file from home directory.\n\
1108 --quiet Do not print version number on startup.\n\
1109 --readnow Fully read symbol files on first access.\n\
1111 fputs_unfiltered (_("\
1112 --se=FILE Use FILE as symbol file and executable file.\n\
1113 --symbols=SYMFILE Read symbols from SYMFILE.\n\
1114 --tty=TTY Use TTY for input/output by the program being debugged.\n\
1117 fputs_unfiltered (_("\
1118 --tui Use a terminal user interface.\n\
1121 fputs_unfiltered (_("\
1122 --version Print version information and then exit.\n\
1123 -w Use a window interface.\n\
1124 --write Set writing into executable and core files.\n\
1125 --xdb XDB compatibility mode.\n\
1127 fputs_unfiltered (_("\n\
1128 At startup, GDB reads the following init files and executes their commands:\n\
1131 fprintf_unfiltered (stream, _("\
1132 * system-wide init file: %s\n\
1133 "), system_gdbinit);
1135 fprintf_unfiltered (stream, _("\
1136 * user-specific init file: %s\n\
1139 fprintf_unfiltered (stream, _("\
1140 * local init file (see also 'set auto-load local-gdbinit'): ./%s\n\
1142 fputs_unfiltered (_("\n\
1143 For more information, type \"help\" from within GDB, or consult the\n\
1144 GDB manual (available as on-line info or a printed manual).\n\
1146 if (REPORT_BUGS_TO[0] && stream == gdb_stdout)
1147 fprintf_unfiltered (stream, _("\
1148 Report bugs to \"%s\".\n\
1149 "), REPORT_BUGS_TO);