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 (*dir
== '\0' || 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},
455 /* This is a synonym for "--annotate=1". --annotate is now
456 preferred, but keep this here for a long time because people
457 will be running emacses which use --fullname. */
458 {"fullname", no_argument
, 0, 'f'},
459 {"f", no_argument
, 0, 'f'},
461 {"annotate", required_argument
, 0, OPT_ANNOTATE
},
462 {"help", no_argument
, &print_help
, 1},
463 {"se", required_argument
, 0, OPT_SE
},
464 {"symbols", required_argument
, 0, 's'},
465 {"s", required_argument
, 0, 's'},
466 {"exec", required_argument
, 0, 'e'},
467 {"e", required_argument
, 0, 'e'},
468 {"core", required_argument
, 0, 'c'},
469 {"c", required_argument
, 0, 'c'},
470 {"pid", required_argument
, 0, 'p'},
471 {"p", required_argument
, 0, 'p'},
472 {"command", required_argument
, 0, 'x'},
473 {"eval-command", required_argument
, 0, 'X'},
474 {"version", no_argument
, &print_version
, 1},
475 {"x", required_argument
, 0, 'x'},
476 {"ex", required_argument
, 0, 'X'},
477 {"init-command", required_argument
, 0, OPT_IX
},
478 {"init-eval-command", required_argument
, 0, OPT_IEX
},
479 {"ix", required_argument
, 0, OPT_IX
},
480 {"iex", required_argument
, 0, OPT_IEX
},
482 {"tclcommand", required_argument
, 0, 'z'},
483 {"enable-external-editor", no_argument
, 0, 'y'},
484 {"editor-command", required_argument
, 0, 'w'},
486 {"ui", required_argument
, 0, 'i'},
487 {"interpreter", required_argument
, 0, 'i'},
488 {"i", required_argument
, 0, 'i'},
489 {"directory", required_argument
, 0, 'd'},
490 {"d", required_argument
, 0, 'd'},
491 {"data-directory", required_argument
, 0, 'D'},
492 {"cd", required_argument
, 0, OPT_CD
},
493 {"tty", required_argument
, 0, 't'},
494 {"baud", required_argument
, 0, 'b'},
495 {"b", required_argument
, 0, 'b'},
496 {"nw", no_argument
, NULL
, OPT_NOWINDOWS
},
497 {"nowindows", no_argument
, NULL
, OPT_NOWINDOWS
},
498 {"w", no_argument
, NULL
, OPT_WINDOWS
},
499 {"windows", no_argument
, NULL
, OPT_WINDOWS
},
500 {"statistics", no_argument
, 0, OPT_STATISTICS
},
501 {"write", no_argument
, &write_files
, 1},
502 {"args", no_argument
, &set_args
, 1},
503 {"l", required_argument
, 0, 'l'},
504 {"return-child-result", no_argument
, &return_child_result
, 1},
505 {0, no_argument
, 0, 0}
512 c
= getopt_long_only (argc
, argv
, "",
513 long_options
, &option_index
);
514 if (c
== EOF
|| set_args
)
517 /* Long option that takes an argument. */
518 if (c
== 0 && long_options
[option_index
].flag
== 0)
519 c
= long_options
[option_index
].val
;
524 /* Long option that just sets a flag. */
534 /* FIXME: what if the syntax is wrong (e.g. not digits)? */
535 annotation_level
= atoi (optarg
);
538 /* Enable the display of both time and space usage. */
539 set_display_time (1);
540 set_display_space (1);
543 /* --tui is equivalent to -i=tui. */
545 xfree (interpreter_p
);
546 interpreter_p
= xstrdup (INTERP_TUI
);
548 fprintf_unfiltered (gdb_stderr
,
549 _("%s: TUI mode is not supported\n"),
555 /* FIXME: cagney/2003-03-01: Not sure if this option is
556 actually useful, and if it is, what it should do. */
558 /* --windows is equivalent to -i=insight. */
559 xfree (interpreter_p
);
560 interpreter_p
= xstrdup (INTERP_INSIGHT
);
565 /* -nw is equivalent to -i=console. */
566 xfree (interpreter_p
);
567 interpreter_p
= xstrdup (INTERP_CONSOLE
);
571 annotation_level
= 1;
572 /* We have probably been invoked from emacs. Disable
590 struct cmdarg cmdarg
= { CMDARG_FILE
, optarg
};
592 VEC_safe_push (cmdarg_s
, cmdarg_vec
, &cmdarg
);
597 struct cmdarg cmdarg
= { CMDARG_COMMAND
, optarg
};
599 VEC_safe_push (cmdarg_s
, cmdarg_vec
, &cmdarg
);
604 struct cmdarg cmdarg
= { CMDARG_INIT_FILE
, optarg
};
606 VEC_safe_push (cmdarg_s
, cmdarg_vec
, &cmdarg
);
611 struct cmdarg cmdarg
= { CMDARG_INIT_COMMAND
, optarg
};
613 VEC_safe_push (cmdarg_s
, cmdarg_vec
, &cmdarg
);
617 batch_flag
= batch_silent
= 1;
618 gdb_stdout
= ui_file_new();
622 gdb_datadir
= xstrdup (optarg
);
623 gdb_datadir_provided
= 1;
628 extern int gdbtk_test (char *);
630 if (!gdbtk_test (optarg
))
632 fprintf_unfiltered (gdb_stderr
,
633 _("%s: unable to load "
634 "tclcommand file \"%s\""),
641 /* Backwards compatibility only. */
645 /* Set the external editor commands when gdb is farming out files
646 to be edited by another program. */
647 extern char *external_editor_command
;
649 external_editor_command
= xstrdup (optarg
);
654 xfree (interpreter_p
);
655 interpreter_p
= xstrdup (optarg
);
658 dirarg
[ndir
++] = optarg
;
662 dirarg
= (char **) xrealloc ((char *) dirarg
,
663 dirsize
* sizeof (*dirarg
));
677 i
= strtol (optarg
, &p
, 0);
678 if (i
== 0 && p
== optarg
)
680 /* Don't use *_filtered or warning() (which relies on
681 current_target) until after initialize_all_files(). */
685 _("warning: could not set baud rate to `%s'.\n"), optarg
);
695 i
= strtol (optarg
, &p
, 0);
696 if (i
== 0 && p
== optarg
)
698 /* Don't use *_filtered or warning() (which relies on
699 current_target) until after initialize_all_files(). */
701 fprintf_unfiltered (gdb_stderr
,
702 _("warning: could not set "
703 "timeout limit to `%s'.\n"), optarg
);
710 fprintf_unfiltered (gdb_stderr
,
711 _("Use `%s --help' for a "
712 "complete list of options.\n"),
718 /* If --help or --version, disable window interface. */
719 if (print_help
|| print_version
)
728 /* Initialize all files. Give the interpreter a chance to take
729 control of the console via the deprecated_init_ui_hook (). */
732 /* Now that gdb_init has created the initial inferior, we're in
733 position to set args for that inferior. */
736 /* The remaining options are the command-line options for the
737 inferior. The first one is the sym/exec file, and the rest
741 fprintf_unfiltered (gdb_stderr
,
742 _("%s: `--args' specified but "
743 "no program specified\n"),
747 symarg
= argv
[optind
];
748 execarg
= argv
[optind
];
750 set_inferior_args_vector (argc
- optind
, &argv
[optind
]);
754 /* OK, that's all the options. */
756 /* The first argument, if specified, is the name of the
760 symarg
= argv
[optind
];
761 execarg
= argv
[optind
];
765 /* If the user hasn't already specified a PID or the name of a
766 core file, then a second optional argument is allowed. If
767 present, this argument should be interpreted as either a
768 PID or a core file, whichever works. */
769 if (pidarg
== NULL
&& corearg
== NULL
&& optind
< argc
)
771 pid_or_core_arg
= argv
[optind
];
775 /* Any argument left on the command line is unexpected and
776 will be ignored. Inform the user. */
778 fprintf_unfiltered (gdb_stderr
,
779 _("Excess command line "
780 "arguments ignored. (%s%s)\n"),
782 (optind
== argc
- 1) ? "" : " ...");
785 /* Lookup gdbinit files. Note that the gdbinit file name may be
786 overriden during file initialization, so get_init_files should be
787 called after gdb_init. */
788 get_init_files (&system_gdbinit
, &home_gdbinit
, &local_gdbinit
);
790 /* Do these (and anything which might call wrap_here or *_filtered)
791 after initialize_all_files() but before the interpreter has been
792 installed. Otherwize the help/version messages will be eaten by
793 the interpreter's output handler. */
797 print_gdb_version (gdb_stdout
);
799 printf_filtered ("\n");
805 print_gdb_help (gdb_stdout
);
806 fputs_unfiltered ("\n", gdb_stdout
);
810 /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
811 GDB retain the old MI1 interpreter startup behavior. Output the
812 copyright message before the interpreter is installed. That way
813 it isn't encapsulated in MI output. */
814 if (!quiet
&& strcmp (interpreter_p
, INTERP_MI1
) == 0)
816 /* Print all the junk at the top, with trailing "..." if we are
817 about to read a symbol file (possibly slowly). */
818 print_gdb_version (gdb_stdout
);
820 printf_filtered ("..");
822 printf_filtered ("\n");
823 gdb_flush (gdb_stdout
); /* Force to screen during slow
827 /* Install the default UI. All the interpreters should have had a
828 look at things by now. Initialize the default interpreter. */
832 struct interp
*interp
= interp_lookup (interpreter_p
);
835 error (_("Interpreter `%s' unrecognized"), interpreter_p
);
837 if (!interp_set (interp
, 1))
839 fprintf_unfiltered (gdb_stderr
,
840 "Interpreter `%s' failed to initialize.\n",
846 /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
847 GDB retain the old MI1 interpreter startup behavior. Output the
848 copyright message after the interpreter is installed when it is
849 any sane interpreter. */
850 if (!quiet
&& !current_interp_named_p (INTERP_MI1
))
852 /* Print all the junk at the top, with trailing "..." if we are
853 about to read a symbol file (possibly slowly). */
854 print_gdb_version (gdb_stdout
);
856 printf_filtered ("..");
858 printf_filtered ("\n");
859 gdb_flush (gdb_stdout
); /* Force to screen during slow
863 /* Set off error and warning messages with a blank line. */
864 error_pre_print
= "\n";
865 quit_pre_print
= error_pre_print
;
866 warning_pre_print
= _("\nwarning: ");
868 /* Read and execute the system-wide gdbinit file, if it exists.
869 This is done *before* all the command line arguments are
870 processed; it sets global parameters, which are independent of
871 what file you are debugging or what directory you are in. */
872 if (system_gdbinit
&& !inhibit_gdbinit
)
873 catch_command_errors (source_script
, system_gdbinit
, 0, RETURN_MASK_ALL
);
875 /* Read and execute $HOME/.gdbinit file, if it exists. This is done
876 *before* all the command line arguments are processed; it sets
877 global parameters, which are independent of what file you are
878 debugging or what directory you are in. */
880 if (home_gdbinit
&& !inhibit_gdbinit
&& !inhibit_home_gdbinit
)
881 catch_command_errors (source_script
, home_gdbinit
, 0, RETURN_MASK_ALL
);
883 /* Process '-ix' and '-iex' options early. */
884 for (i
= 0; VEC_iterate (cmdarg_s
, cmdarg_vec
, i
, cmdarg_p
); i
++)
885 switch (cmdarg_p
->type
)
887 case CMDARG_INIT_FILE
:
888 catch_command_errors (source_script
, cmdarg_p
->string
,
889 !batch_flag
, RETURN_MASK_ALL
);
891 case CMDARG_INIT_COMMAND
:
892 catch_command_errors (execute_command
, cmdarg_p
->string
,
893 !batch_flag
, RETURN_MASK_ALL
);
897 /* Now perform all the actions indicated by the arguments. */
900 catch_command_errors (cd_command
, cdarg
, 0, RETURN_MASK_ALL
);
903 for (i
= 0; i
< ndir
; i
++)
904 catch_command_errors (directory_switch
, dirarg
[i
], 0, RETURN_MASK_ALL
);
907 /* Skip auto-loading section-specified scripts until we've sourced
908 local_gdbinit (which is often used to augment the source search
910 save_auto_load
= global_auto_load
;
911 global_auto_load
= 0;
915 && strcmp (execarg
, symarg
) == 0)
917 /* The exec file and the symbol-file are the same. If we can't
918 open it, better only print one error message.
919 catch_command_errors returns non-zero on success! */
920 if (catch_command_errors (exec_file_attach
, execarg
,
921 !batch_flag
, RETURN_MASK_ALL
))
922 catch_command_errors (symbol_file_add_main
, symarg
,
923 !batch_flag
, RETURN_MASK_ALL
);
928 catch_command_errors (exec_file_attach
, execarg
,
929 !batch_flag
, RETURN_MASK_ALL
);
931 catch_command_errors (symbol_file_add_main
, symarg
,
932 !batch_flag
, RETURN_MASK_ALL
);
935 if (corearg
&& pidarg
)
936 error (_("Can't attach to process and specify "
937 "a core file at the same time."));
940 catch_command_errors (core_file_command
, corearg
,
941 !batch_flag
, RETURN_MASK_ALL
);
942 else if (pidarg
!= NULL
)
943 catch_command_errors (attach_command
, pidarg
,
944 !batch_flag
, RETURN_MASK_ALL
);
945 else if (pid_or_core_arg
)
947 /* The user specified 'gdb program pid' or gdb program core'.
948 If pid_or_core_arg's first character is a digit, try attach
949 first and then corefile. Otherwise try just corefile. */
951 if (isdigit (pid_or_core_arg
[0]))
953 if (catch_command_errors (attach_command
, pid_or_core_arg
,
954 !batch_flag
, RETURN_MASK_ALL
) == 0)
955 catch_command_errors (core_file_command
, pid_or_core_arg
,
956 !batch_flag
, RETURN_MASK_ALL
);
958 else /* Can't be a pid, better be a corefile. */
959 catch_command_errors (core_file_command
, pid_or_core_arg
,
960 !batch_flag
, RETURN_MASK_ALL
);
964 set_inferior_io_terminal (ttyarg
);
966 /* Error messages should no longer be distinguished with extra output. */
967 error_pre_print
= NULL
;
968 quit_pre_print
= NULL
;
969 warning_pre_print
= _("warning: ");
971 /* Read the .gdbinit file in the current directory, *if* it isn't
972 the same as the $HOME/.gdbinit file (it should exist, also). */
975 auto_load_local_gdbinit_pathname
= gdb_realpath (local_gdbinit
);
977 if (!inhibit_gdbinit
&& auto_load_local_gdbinit
978 && file_is_auto_load_safe (local_gdbinit
,
979 _("auto-load: Loading .gdbinit "
983 auto_load_local_gdbinit_loaded
= 1;
985 catch_command_errors (source_script
, local_gdbinit
, 0,
990 /* Now that all .gdbinit's have been read and all -d options have been
991 processed, we can read any scripts mentioned in SYMARG.
992 We wait until now because it is common to add to the source search
993 path in local_gdbinit. */
994 global_auto_load
= save_auto_load
;
995 ALL_OBJFILES (objfile
)
996 load_auto_scripts_for_objfile (objfile
);
998 /* Process '-x' and '-ex' options. */
999 for (i
= 0; VEC_iterate (cmdarg_s
, cmdarg_vec
, i
, cmdarg_p
); i
++)
1000 switch (cmdarg_p
->type
)
1003 catch_command_errors (source_script
, cmdarg_p
->string
,
1004 !batch_flag
, RETURN_MASK_ALL
);
1006 case CMDARG_COMMAND
:
1007 catch_command_errors (execute_command
, cmdarg_p
->string
,
1008 !batch_flag
, RETURN_MASK_ALL
);
1012 /* Read in the old history after all the command files have been
1018 /* We have hit the end of the batch file. */
1019 quit_force (NULL
, 0);
1022 /* Show time and/or space usage. */
1023 do_cleanups (pre_stat_chain
);
1025 /* NOTE: cagney/1999-11-07: There is probably no reason for not
1026 moving this loop and the code found in captured_command_loop()
1027 into the command_loop() proper. The main thing holding back that
1028 change - SET_TOP_LEVEL() - has been eliminated. */
1031 catch_errors (captured_command_loop
, 0, "", RETURN_MASK_ALL
);
1033 /* No exit -- exit is through quit_command. */
1037 gdb_main (struct captured_main_args
*args
)
1039 use_windows
= args
->use_windows
;
1040 catch_errors (captured_main
, args
, "", RETURN_MASK_ALL
);
1041 /* The only way to end up here is by an error (normal exit is
1042 handled by quit_force()), hence always return an error status. */
1047 /* Don't use *_filtered for printing help. We don't want to prompt
1048 for continue no matter how small the screen or how much we're going
1052 print_gdb_help (struct ui_file
*stream
)
1054 char *system_gdbinit
;
1056 char *local_gdbinit
;
1058 get_init_files (&system_gdbinit
, &home_gdbinit
, &local_gdbinit
);
1060 fputs_unfiltered (_("\
1061 This is the GNU debugger. Usage:\n\n\
1062 gdb [options] [executable-file [core-file or process-id]]\n\
1063 gdb [options] --args executable-file [inferior-arguments ...]\n\n\
1066 fputs_unfiltered (_("\
1067 --args Arguments after executable-file are passed to inferior\n\
1069 fputs_unfiltered (_("\
1070 -b BAUDRATE Set serial port baud rate used for remote debugging.\n\
1071 --batch Exit after processing options.\n\
1072 --batch-silent As for --batch, but suppress all gdb stdout output.\n\
1073 --return-child-result\n\
1074 GDB exit code will be the child's exit code.\n\
1075 --cd=DIR Change current directory to DIR.\n\
1076 --command=FILE, -x Execute GDB commands from FILE.\n\
1077 --eval-command=COMMAND, -ex\n\
1078 Execute a single GDB command.\n\
1079 May be used multiple times and in conjunction\n\
1081 --init-command=FILE, -ix Like -x but execute it before loading inferior.\n\
1082 --init-eval-command=COMMAND, -iex Like -ex but before loading inferior.\n\
1083 --core=COREFILE Analyze the core dump COREFILE.\n\
1084 --pid=PID Attach to running process PID.\n\
1086 fputs_unfiltered (_("\
1087 --dbx DBX compatibility mode.\n\
1088 --directory=DIR Search for source files in DIR.\n\
1089 --epoch Output information used by epoch emacs-GDB interface.\n\
1090 --exec=EXECFILE Use EXECFILE as the executable.\n\
1091 --fullname Output information used by emacs-GDB interface.\n\
1092 --help Print this message.\n\
1094 fputs_unfiltered (_("\
1095 --interpreter=INTERP\n\
1096 Select a specific interpreter / user interface\n\
1098 fputs_unfiltered (_("\
1099 -l TIMEOUT Set timeout in seconds for remote debugging.\n\
1100 --nw Do not use a window interface.\n\
1101 --nx Do not read any "), stream
);
1102 fputs_unfiltered (gdbinit
, stream
);
1103 fputs_unfiltered (_(" files.\n\
1104 --nh Do not read "), stream
);
1105 fputs_unfiltered (gdbinit
, stream
);
1106 fputs_unfiltered (_(" file from home directory.\n\
1107 --quiet Do not print version number on startup.\n\
1108 --readnow Fully read symbol files on first access.\n\
1110 fputs_unfiltered (_("\
1111 --se=FILE Use FILE as symbol file and executable file.\n\
1112 --symbols=SYMFILE Read symbols from SYMFILE.\n\
1113 --tty=TTY Use TTY for input/output by the program being debugged.\n\
1116 fputs_unfiltered (_("\
1117 --tui Use a terminal user interface.\n\
1120 fputs_unfiltered (_("\
1121 --version Print version information and then exit.\n\
1122 -w Use a window interface.\n\
1123 --write Set writing into executable and core files.\n\
1124 --xdb XDB compatibility mode.\n\
1126 fputs_unfiltered (_("\n\
1127 At startup, GDB reads the following init files and executes their commands:\n\
1130 fprintf_unfiltered (stream
, _("\
1131 * system-wide init file: %s\n\
1132 "), system_gdbinit
);
1134 fprintf_unfiltered (stream
, _("\
1135 * user-specific init file: %s\n\
1138 fprintf_unfiltered (stream
, _("\
1139 * local init file (see also 'set auto-load local-gdbinit'): ./%s\n\
1141 fputs_unfiltered (_("\n\
1142 For more information, type \"help\" from within GDB, or consult the\n\
1143 GDB manual (available as on-line info or a printed manual).\n\
1145 if (REPORT_BUGS_TO
[0] && stream
== gdb_stdout
)
1146 fprintf_unfiltered (stream
, _("\
1147 Report bugs to \"%s\".\n\
1148 "), REPORT_BUGS_TO
);