rtld - do not allow both dynamic DTV index and static TLS offset
[dragonfly.git] / contrib / gdb-7 / gdb / main.c
blob09c5fd9d8e3d7d0cadf485eccf901f7287c3a907
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/>. */
20 #include "defs.h"
21 #include "top.h"
22 #include "target.h"
23 #include "inferior.h"
24 #include "symfile.h"
25 #include "gdbcore.h"
27 #include "exceptions.h"
28 #include "getopt.h"
30 #include <sys/types.h>
31 #include "gdb_stat.h"
32 #include <ctype.h>
34 #include "gdb_string.h"
35 #include "event-loop.h"
36 #include "ui-out.h"
38 #include "interps.h"
39 #include "main.h"
40 #include "source.h"
41 #include "cli/cli-cmds.h"
42 #include "python/python.h"
43 #include "objfiles.h"
44 #include "auto-load.h"
46 #include "filenames.h"
48 /* The selected interpreter. This will be used as a set command
49 variable, so it should always be malloc'ed - since
50 do_setshow_command will free it. */
51 char *interpreter_p;
53 /* Whether xdb commands will be handled. */
54 int xdb_commands = 0;
56 /* Whether dbx commands will be handled. */
57 int dbx_commands = 0;
59 /* System root path, used to find libraries etc. */
60 char *gdb_sysroot = 0;
62 /* GDB datadir, used to store data files. */
63 char *gdb_datadir = 0;
65 /* Non-zero if GDB_DATADIR was provided on the command line.
66 This doesn't track whether data-directory is set later from the
67 command line, but we don't reread system.gdbinit when that happens. */
68 static int gdb_datadir_provided = 0;
70 /* If gdb was configured with --with-python=/path,
71 the possibly relocated path to python's lib directory. */
72 char *python_libdir = 0;
74 struct ui_file *gdb_stdout;
75 struct ui_file *gdb_stderr;
76 struct ui_file *gdb_stdlog;
77 struct ui_file *gdb_stdin;
78 /* Target IO streams. */
79 struct ui_file *gdb_stdtargin;
80 struct ui_file *gdb_stdtarg;
81 struct ui_file *gdb_stdtargerr;
83 /* True if --batch or --batch-silent was seen. */
84 int batch_flag = 0;
86 /* Support for the --batch-silent option. */
87 int batch_silent = 0;
89 /* Support for --return-child-result option.
90 Set the default to -1 to return error in the case
91 that the program does not run or does not complete. */
92 int return_child_result = 0;
93 int return_child_result_value = -1;
96 /* GDB as it has been invoked from the command line (i.e. argv[0]). */
97 static char *gdb_program_name;
99 /* DragonFly kgdb support */
100 int kernel_debugger;
102 static void print_gdb_help (struct ui_file *);
104 /* Relocate a file or directory. PROGNAME is the name by which gdb
105 was invoked (i.e., argv[0]). INITIAL is the default value for the
106 file or directory. FLAG is true if the value is relocatable, false
107 otherwise. Returns a newly allocated string; this may return NULL
108 under the same conditions as make_relative_prefix. */
110 static char *
111 relocate_path (const char *progname, const char *initial, int flag)
113 if (flag)
114 return make_relative_prefix (progname, BINDIR, initial);
115 return xstrdup (initial);
118 /* Like relocate_path, but specifically checks for a directory.
119 INITIAL is relocated according to the rules of relocate_path. If
120 the result is a directory, it is used; otherwise, INITIAL is used.
121 The chosen directory is then canonicalized using lrealpath. This
122 function always returns a newly-allocated string. */
124 char *
125 relocate_gdb_directory (const char *initial, int flag)
127 char *dir;
129 dir = relocate_path (gdb_program_name, initial, flag);
130 if (dir)
132 struct stat s;
134 if (*dir == '\0' || stat (dir, &s) != 0 || !S_ISDIR (s.st_mode))
136 xfree (dir);
137 dir = NULL;
140 if (!dir)
141 dir = xstrdup (initial);
143 /* Canonicalize the directory. */
144 if (*dir)
146 char *canon_sysroot = lrealpath (dir);
148 if (canon_sysroot)
150 xfree (dir);
151 dir = canon_sysroot;
155 return dir;
158 /* Compute the locations of init files that GDB should source and
159 return them in SYSTEM_GDBINIT, HOME_GDBINIT, LOCAL_GDBINIT. If
160 there is no system gdbinit (resp. home gdbinit and local gdbinit)
161 to be loaded, then SYSTEM_GDBINIT (resp. HOME_GDBINIT and
162 LOCAL_GDBINIT) is set to NULL. */
163 static void
164 get_init_files (char **system_gdbinit,
165 char **home_gdbinit,
166 char **local_gdbinit)
168 static char *sysgdbinit = NULL;
169 static char *homeinit = NULL;
170 static char *localinit = NULL;
171 static int initialized = 0;
173 if (!initialized)
175 struct stat homebuf, cwdbuf, s;
176 char *homedir;
178 if (SYSTEM_GDBINIT[0])
180 int datadir_len = strlen (GDB_DATADIR);
181 int sys_gdbinit_len = strlen (SYSTEM_GDBINIT);
182 char *relocated_sysgdbinit;
184 /* If SYSTEM_GDBINIT lives in data-directory, and data-directory
185 has been provided, search for SYSTEM_GDBINIT there. */
186 if (gdb_datadir_provided
187 && datadir_len < sys_gdbinit_len
188 && filename_ncmp (SYSTEM_GDBINIT, GDB_DATADIR, datadir_len) == 0
189 && IS_DIR_SEPARATOR (SYSTEM_GDBINIT[datadir_len]))
191 /* Append the part of SYSTEM_GDBINIT that follows GDB_DATADIR
192 to gdb_datadir. */
193 char *tmp_sys_gdbinit = xstrdup (SYSTEM_GDBINIT + datadir_len);
194 char *p;
196 for (p = tmp_sys_gdbinit; IS_DIR_SEPARATOR (*p); ++p)
197 continue;
198 relocated_sysgdbinit = concat (gdb_datadir, SLASH_STRING, p,
199 NULL);
200 xfree (tmp_sys_gdbinit);
202 else
204 relocated_sysgdbinit = relocate_path (gdb_program_name,
205 SYSTEM_GDBINIT,
206 SYSTEM_GDBINIT_RELOCATABLE);
208 if (relocated_sysgdbinit && stat (relocated_sysgdbinit, &s) == 0)
209 sysgdbinit = relocated_sysgdbinit;
210 else
211 xfree (relocated_sysgdbinit);
214 homedir = getenv ("HOME");
216 /* If the .gdbinit file in the current directory is the same as
217 the $HOME/.gdbinit file, it should not be sourced. homebuf
218 and cwdbuf are used in that purpose. Make sure that the stats
219 are zero in case one of them fails (this guarantees that they
220 won't match if either exists). */
222 memset (&homebuf, 0, sizeof (struct stat));
223 memset (&cwdbuf, 0, sizeof (struct stat));
225 if (homedir)
227 homeinit = xstrprintf ("%s/%s", homedir, gdbinit);
228 if (stat (homeinit, &homebuf) != 0)
230 xfree (homeinit);
231 homeinit = NULL;
235 if (stat (gdbinit, &cwdbuf) == 0)
237 if (!homeinit
238 || memcmp ((char *) &homebuf, (char *) &cwdbuf,
239 sizeof (struct stat)))
240 localinit = gdbinit;
243 initialized = 1;
246 *system_gdbinit = sysgdbinit;
247 *home_gdbinit = homeinit;
248 *local_gdbinit = localinit;
251 /* Call command_loop. If it happens to return, pass that through as a
252 non-zero return status. */
254 static int
255 captured_command_loop (void *data)
257 /* Top-level execution commands can be run on the background from
258 here on. */
259 interpreter_async = 1;
261 current_interp_command_loop ();
262 /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
263 would clean things up (restoring the cleanup chain) to the state
264 they were just prior to the call. Technically, this means that
265 the do_cleanups() below is redundant. Unfortunately, many FUNCs
266 are not that well behaved. do_cleanups should either be replaced
267 with a do_cleanups call (to cover the problem) or an assertion
268 check to detect bad FUNCs code. */
269 do_cleanups (all_cleanups ());
270 /* If the command_loop returned, normally (rather than threw an
271 error) we try to quit. If the quit is aborted, catch_errors()
272 which called this catch the signal and restart the command
273 loop. */
274 quit_command (NULL, instream == stdin);
275 return 1;
278 /* Arguments of --command option and its counterpart. */
279 typedef struct cmdarg {
280 /* Type of this option. */
281 enum {
282 /* Option type -x. */
283 CMDARG_FILE,
285 /* Option type -ex. */
286 CMDARG_COMMAND,
288 /* Option type -ix. */
289 CMDARG_INIT_FILE,
291 /* Option type -iex. */
292 CMDARG_INIT_COMMAND
293 } type;
295 /* Value of this option - filename or the GDB command itself. String memory
296 is not owned by this structure despite it is 'const'. */
297 char *string;
298 } cmdarg_s;
300 /* Define type VEC (cmdarg_s). */
301 DEF_VEC_O (cmdarg_s);
303 static int
304 captured_main (void *data)
306 struct captured_main_args *context = data;
307 int argc = context->argc;
308 char **argv = context->argv;
309 static int quiet = 0;
310 static int set_args = 0;
311 static int inhibit_home_gdbinit = 0;
313 /* Pointers to various arguments from command line. */
314 char *symarg = NULL;
315 char *execarg = NULL;
316 char *pidarg = NULL;
317 char *corearg = NULL;
318 char *pid_or_core_arg = NULL;
319 char *cdarg = NULL;
320 char *ttyarg = NULL;
322 /* These are static so that we can take their address in an
323 initializer. */
324 static int print_help;
325 static int print_version;
327 /* Pointers to all arguments of --command option. */
328 VEC (cmdarg_s) *cmdarg_vec = NULL;
329 struct cmdarg *cmdarg_p;
331 /* Indices of all arguments of --directory option. */
332 char **dirarg;
333 /* Allocated size. */
334 int dirsize;
335 /* Number of elements used. */
336 int ndir;
338 /* gdb init files. */
339 char *system_gdbinit;
340 char *home_gdbinit;
341 char *local_gdbinit;
343 int i;
344 int save_auto_load;
345 struct objfile *objfile;
347 struct cleanup *pre_stat_chain;
349 #ifdef HAVE_SBRK
350 /* Set this before calling make_command_stats_cleanup. */
351 lim_at_start = (char *) sbrk (0);
352 #endif
354 pre_stat_chain = make_command_stats_cleanup (0);
356 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
357 setlocale (LC_MESSAGES, "");
358 #endif
359 #if defined (HAVE_SETLOCALE)
360 setlocale (LC_CTYPE, "");
361 #endif
362 bindtextdomain (PACKAGE, LOCALEDIR);
363 textdomain (PACKAGE);
365 bfd_init ();
367 make_cleanup (VEC_cleanup (cmdarg_s), &cmdarg_vec);
368 dirsize = 1;
369 dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
370 ndir = 0;
372 clear_quit_flag ();
373 saved_command_line = (char *) xmalloc (saved_command_line_size);
374 saved_command_line[0] = '\0';
375 instream = stdin;
377 gdb_stdout = stdio_fileopen (stdout);
378 gdb_stderr = stdio_fileopen (stderr);
379 gdb_stdlog = gdb_stderr; /* for moment */
380 gdb_stdtarg = gdb_stderr; /* for moment */
381 gdb_stdin = stdio_fileopen (stdin);
382 gdb_stdtargerr = gdb_stderr; /* for moment */
383 gdb_stdtargin = gdb_stdin; /* for moment */
385 #ifdef __MINGW32__
386 /* On Windows, argv[0] is not necessarily set to absolute form when
387 GDB is found along PATH, without which relocation doesn't work. */
388 gdb_program_name = windows_get_absolute_argv0 (argv[0]);
389 #else
390 gdb_program_name = xstrdup (argv[0]);
391 #endif
393 if (! getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)))
394 /* Don't use *_filtered or warning() (which relies on
395 current_target) until after initialize_all_files(). */
396 fprintf_unfiltered (gdb_stderr,
397 _("%s: warning: error finding "
398 "working directory: %s\n"),
399 argv[0], safe_strerror (errno));
401 current_directory = gdb_dirbuf;
403 /* Set the sysroot path. */
404 gdb_sysroot = relocate_gdb_directory (TARGET_SYSTEM_ROOT,
405 TARGET_SYSTEM_ROOT_RELOCATABLE);
407 debug_file_directory = relocate_gdb_directory (DEBUGDIR,
408 DEBUGDIR_RELOCATABLE);
410 gdb_datadir = relocate_gdb_directory (GDB_DATADIR,
411 GDB_DATADIR_RELOCATABLE);
413 #ifdef WITH_PYTHON_PATH
415 /* For later use in helping Python find itself. */
416 char *tmp = concat (WITH_PYTHON_PATH, SLASH_STRING, "lib", NULL);
418 python_libdir = relocate_gdb_directory (tmp, PYTHON_PATH_RELOCATABLE);
419 xfree (tmp);
421 #endif
423 #ifdef RELOC_SRCDIR
424 add_substitute_path_rule (RELOC_SRCDIR,
425 make_relative_prefix (gdb_program_name, BINDIR,
426 RELOC_SRCDIR));
427 #endif
429 /* There will always be an interpreter. Either the one passed into
430 this captured main, or one specified by the user at start up, or
431 the console. Initialize the interpreter to the one requested by
432 the application. */
433 interpreter_p = xstrdup (context->interpreter_p);
435 /* Parse arguments and options. */
437 int c;
438 /* When var field is 0, use flag field to record the equivalent
439 short option (or arbitrary numbers starting at 10 for those
440 with no equivalent). */
441 enum {
442 OPT_SE = 10,
443 OPT_CD,
444 OPT_ANNOTATE,
445 OPT_STATISTICS,
446 OPT_TUI,
447 OPT_KGDB,
448 OPT_NOWINDOWS,
449 OPT_WINDOWS,
450 OPT_IX,
451 OPT_IEX
453 static struct option long_options[] =
455 {"tui", no_argument, 0, OPT_TUI},
456 {"xdb", no_argument, &xdb_commands, 1},
457 {"dbx", no_argument, &dbx_commands, 1},
458 {"readnow", no_argument, &readnow_symbol_files, 1},
459 {"r", no_argument, &readnow_symbol_files, 1},
460 {"quiet", no_argument, &quiet, 1},
461 {"q", no_argument, &quiet, 1},
462 {"silent", no_argument, &quiet, 1},
463 {"nh", no_argument, &inhibit_home_gdbinit, 1},
464 {"nx", no_argument, &inhibit_gdbinit, 1},
465 {"n", no_argument, &inhibit_gdbinit, 1},
466 {"batch-silent", no_argument, 0, 'B'},
467 {"batch", no_argument, &batch_flag, 1},
469 /* This is a synonym for "--annotate=1". --annotate is now
470 preferred, but keep this here for a long time because people
471 will be running emacses which use --fullname. */
472 {"fullname", no_argument, 0, 'f'},
473 {"f", no_argument, 0, 'f'},
475 {"kernel", no_argument, 0, OPT_KGDB},
476 {"annotate", required_argument, 0, OPT_ANNOTATE},
477 {"help", no_argument, &print_help, 1},
478 {"se", required_argument, 0, OPT_SE},
479 {"symbols", required_argument, 0, 's'},
480 {"s", required_argument, 0, 's'},
481 {"exec", required_argument, 0, 'e'},
482 {"e", required_argument, 0, 'e'},
483 {"core", required_argument, 0, 'c'},
484 {"c", required_argument, 0, 'c'},
485 {"pid", required_argument, 0, 'p'},
486 {"p", required_argument, 0, 'p'},
487 {"command", required_argument, 0, 'x'},
488 {"eval-command", required_argument, 0, 'X'},
489 {"version", no_argument, &print_version, 1},
490 {"x", required_argument, 0, 'x'},
491 {"ex", required_argument, 0, 'X'},
492 {"init-command", required_argument, 0, OPT_IX},
493 {"init-eval-command", required_argument, 0, OPT_IEX},
494 {"ix", required_argument, 0, OPT_IX},
495 {"iex", required_argument, 0, OPT_IEX},
496 #ifdef GDBTK
497 {"tclcommand", required_argument, 0, 'z'},
498 {"enable-external-editor", no_argument, 0, 'y'},
499 {"editor-command", required_argument, 0, 'w'},
500 #endif
501 {"ui", required_argument, 0, 'i'},
502 {"interpreter", required_argument, 0, 'i'},
503 {"i", required_argument, 0, 'i'},
504 {"directory", required_argument, 0, 'd'},
505 {"d", required_argument, 0, 'd'},
506 {"data-directory", required_argument, 0, 'D'},
507 {"cd", required_argument, 0, OPT_CD},
508 {"tty", required_argument, 0, 't'},
509 {"baud", required_argument, 0, 'b'},
510 {"b", required_argument, 0, 'b'},
511 {"nw", no_argument, NULL, OPT_NOWINDOWS},
512 {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
513 {"w", no_argument, NULL, OPT_WINDOWS},
514 {"windows", no_argument, NULL, OPT_WINDOWS},
515 {"statistics", no_argument, 0, OPT_STATISTICS},
516 {"write", no_argument, &write_files, 1},
517 {"args", no_argument, &set_args, 1},
518 {"l", required_argument, 0, 'l'},
519 {"return-child-result", no_argument, &return_child_result, 1},
520 {0, no_argument, 0, 0}
523 while (1)
525 int option_index;
527 c = getopt_long_only (argc, argv, "",
528 long_options, &option_index);
529 if (c == EOF || set_args)
530 break;
532 /* Long option that takes an argument. */
533 if (c == 0 && long_options[option_index].flag == 0)
534 c = long_options[option_index].val;
536 switch (c)
538 case 0:
539 /* Long option that just sets a flag. */
540 break;
541 case OPT_SE:
542 symarg = optarg;
543 execarg = optarg;
544 break;
545 case OPT_CD:
546 cdarg = optarg;
547 break;
548 case OPT_ANNOTATE:
549 /* FIXME: what if the syntax is wrong (e.g. not digits)? */
550 annotation_level = atoi (optarg);
551 break;
552 case OPT_STATISTICS:
553 /* Enable the display of both time and space usage. */
554 set_display_time (1);
555 set_display_space (1);
556 break;
557 case OPT_TUI:
558 /* --tui is equivalent to -i=tui. */
559 #ifdef TUI
560 xfree (interpreter_p);
561 interpreter_p = xstrdup (INTERP_TUI);
562 #else
563 fprintf_unfiltered (gdb_stderr,
564 _("%s: TUI mode is not supported\n"),
565 argv[0]);
566 exit (1);
567 #endif
568 break;
569 case OPT_KGDB:
570 kernel_debugger = 1;
571 break;
572 case OPT_WINDOWS:
573 /* FIXME: cagney/2003-03-01: Not sure if this option is
574 actually useful, and if it is, what it should do. */
575 #ifdef GDBTK
576 /* --windows is equivalent to -i=insight. */
577 xfree (interpreter_p);
578 interpreter_p = xstrdup (INTERP_INSIGHT);
579 #endif
580 use_windows = 1;
581 break;
582 case OPT_NOWINDOWS:
583 /* -nw is equivalent to -i=console. */
584 xfree (interpreter_p);
585 interpreter_p = xstrdup (INTERP_CONSOLE);
586 use_windows = 0;
587 break;
588 case 'f':
589 annotation_level = 1;
590 /* We have probably been invoked from emacs. Disable
591 window interface. */
592 use_windows = 0;
593 break;
594 case 's':
595 symarg = optarg;
596 break;
597 case 'e':
598 execarg = optarg;
599 break;
600 case 'c':
601 corearg = optarg;
602 break;
603 case 'p':
604 pidarg = optarg;
605 break;
606 case 'x':
608 struct cmdarg cmdarg = { CMDARG_FILE, optarg };
610 VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
612 break;
613 case 'X':
615 struct cmdarg cmdarg = { CMDARG_COMMAND, optarg };
617 VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
619 break;
620 case OPT_IX:
622 struct cmdarg cmdarg = { CMDARG_INIT_FILE, optarg };
624 VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
626 break;
627 case OPT_IEX:
629 struct cmdarg cmdarg = { CMDARG_INIT_COMMAND, optarg };
631 VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
633 break;
634 case 'B':
635 batch_flag = batch_silent = 1;
636 gdb_stdout = ui_file_new();
637 break;
638 case 'D':
639 xfree (gdb_datadir);
640 gdb_datadir = xstrdup (optarg);
641 gdb_datadir_provided = 1;
642 break;
643 #ifdef GDBTK
644 case 'z':
646 extern int gdbtk_test (char *);
648 if (!gdbtk_test (optarg))
650 fprintf_unfiltered (gdb_stderr,
651 _("%s: unable to load "
652 "tclcommand file \"%s\""),
653 argv[0], optarg);
654 exit (1);
656 break;
658 case 'y':
659 /* Backwards compatibility only. */
660 break;
661 case 'w':
663 /* Set the external editor commands when gdb is farming out files
664 to be edited by another program. */
665 extern char *external_editor_command;
667 external_editor_command = xstrdup (optarg);
668 break;
670 #endif /* GDBTK */
671 case 'i':
672 xfree (interpreter_p);
673 interpreter_p = xstrdup (optarg);
674 break;
675 case 'd':
676 dirarg[ndir++] = optarg;
677 if (ndir >= dirsize)
679 dirsize *= 2;
680 dirarg = (char **) xrealloc ((char *) dirarg,
681 dirsize * sizeof (*dirarg));
683 break;
684 case 't':
685 ttyarg = optarg;
686 break;
687 case 'q':
688 quiet = 1;
689 break;
690 case 'b':
692 int i;
693 char *p;
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
702 (gdb_stderr,
703 _("warning: could not set baud rate to `%s'.\n"), optarg);
704 else
705 baud_rate = i;
707 break;
708 case 'l':
710 int i;
711 char *p;
713 i = strtol (optarg, &p, 0);
714 if (i == 0 && p == optarg)
716 /* Don't use *_filtered or warning() (which relies on
717 current_target) until after initialize_all_files(). */
719 fprintf_unfiltered (gdb_stderr,
720 _("warning: could not set "
721 "timeout limit to `%s'.\n"), optarg);
722 else
723 remote_timeout = i;
725 break;
727 case '?':
728 fprintf_unfiltered (gdb_stderr,
729 _("Use `%s --help' for a "
730 "complete list of options.\n"),
731 argv[0]);
732 exit (1);
736 /* If --help or --version, disable window interface. */
737 if (print_help || print_version)
739 use_windows = 0;
742 if (batch_flag)
743 quiet = 1;
746 /* Initialize all files. Give the interpreter a chance to take
747 control of the console via the deprecated_init_ui_hook (). */
748 gdb_init (gdb_program_name);
750 /* Now that gdb_init has created the initial inferior, we're in
751 position to set args for that inferior. */
752 if (set_args)
754 /* The remaining options are the command-line options for the
755 inferior. The first one is the sym/exec file, and the rest
756 are arguments. */
757 if (optind >= argc)
759 fprintf_unfiltered (gdb_stderr,
760 _("%s: `--args' specified but "
761 "no program specified\n"),
762 argv[0]);
763 exit (1);
765 symarg = argv[optind];
766 execarg = argv[optind];
767 ++optind;
768 set_inferior_args_vector (argc - optind, &argv[optind]);
770 else
772 /* OK, that's all the options. */
774 /* The first argument, if specified, is the name of the
775 executable. */
776 if (optind < argc)
778 symarg = argv[optind];
779 execarg = argv[optind];
780 optind++;
783 /* If the user hasn't already specified a PID or the name of a
784 core file, then a second optional argument is allowed. If
785 present, this argument should be interpreted as either a
786 PID or a core file, whichever works. */
787 if (pidarg == NULL && corearg == NULL && optind < argc)
789 pid_or_core_arg = argv[optind];
790 optind++;
793 /* Any argument left on the command line is unexpected and
794 will be ignored. Inform the user. */
795 if (optind < argc)
796 fprintf_unfiltered (gdb_stderr,
797 _("Excess command line "
798 "arguments ignored. (%s%s)\n"),
799 argv[optind],
800 (optind == argc - 1) ? "" : " ...");
803 /* Lookup gdbinit files. Note that the gdbinit file name may be
804 overriden during file initialization, so get_init_files should be
805 called after gdb_init. */
806 get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
808 /* Do these (and anything which might call wrap_here or *_filtered)
809 after initialize_all_files() but before the interpreter has been
810 installed. Otherwize the help/version messages will be eaten by
811 the interpreter's output handler. */
813 if (print_version)
815 print_gdb_version (gdb_stdout);
816 wrap_here ("");
817 printf_filtered ("\n");
818 exit (0);
821 if (print_help)
823 print_gdb_help (gdb_stdout);
824 fputs_unfiltered ("\n", gdb_stdout);
825 exit (0);
828 /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
829 GDB retain the old MI1 interpreter startup behavior. Output the
830 copyright message before the interpreter is installed. That way
831 it isn't encapsulated in MI output. */
832 if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
834 /* Print all the junk at the top, with trailing "..." if we are
835 about to read a symbol file (possibly slowly). */
836 print_gdb_version (gdb_stdout);
837 if (symarg)
838 printf_filtered ("..");
839 wrap_here ("");
840 printf_filtered ("\n");
841 gdb_flush (gdb_stdout); /* Force to screen during slow
842 operations. */
845 /* Install the default UI. All the interpreters should have had a
846 look at things by now. Initialize the default interpreter. */
849 /* Find it. */
850 struct interp *interp = interp_lookup (interpreter_p);
852 if (interp == NULL)
853 error (_("Interpreter `%s' unrecognized"), interpreter_p);
854 /* Install it. */
855 if (!interp_set (interp, 1))
857 fprintf_unfiltered (gdb_stderr,
858 "Interpreter `%s' failed to initialize.\n",
859 interpreter_p);
860 exit (1);
864 /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
865 GDB retain the old MI1 interpreter startup behavior. Output the
866 copyright message after the interpreter is installed when it is
867 any sane interpreter. */
868 if (!quiet && !current_interp_named_p (INTERP_MI1))
870 /* Print all the junk at the top, with trailing "..." if we are
871 about to read a symbol file (possibly slowly). */
872 print_gdb_version (gdb_stdout);
873 if (symarg)
874 printf_filtered ("..");
875 wrap_here ("");
876 printf_filtered ("\n");
877 gdb_flush (gdb_stdout); /* Force to screen during slow
878 operations. */
881 /* Set off error and warning messages with a blank line. */
882 error_pre_print = "\n";
883 quit_pre_print = error_pre_print;
884 warning_pre_print = _("\nwarning: ");
886 /* Read and execute the system-wide gdbinit file, if it exists.
887 This is done *before* all the command line arguments are
888 processed; it sets global parameters, which are independent of
889 what file you are debugging or what directory you are in. */
890 if (system_gdbinit && !inhibit_gdbinit)
891 catch_command_errors (source_script, system_gdbinit, 0, RETURN_MASK_ALL);
893 /* Read and execute $HOME/.gdbinit file, if it exists. This is done
894 *before* all the command line arguments are processed; it sets
895 global parameters, which are independent of what file you are
896 debugging or what directory you are in. */
898 if (home_gdbinit && !inhibit_gdbinit && !inhibit_home_gdbinit)
899 catch_command_errors (source_script, home_gdbinit, 0, RETURN_MASK_ALL);
901 /* Process '-ix' and '-iex' options early. */
902 for (i = 0; VEC_iterate (cmdarg_s, cmdarg_vec, i, cmdarg_p); i++)
903 switch (cmdarg_p->type)
905 case CMDARG_INIT_FILE:
906 catch_command_errors (source_script, cmdarg_p->string,
907 !batch_flag, RETURN_MASK_ALL);
908 break;
909 case CMDARG_INIT_COMMAND:
910 catch_command_errors (execute_command, cmdarg_p->string,
911 !batch_flag, RETURN_MASK_ALL);
912 break;
915 /* Now perform all the actions indicated by the arguments. */
916 if (cdarg != NULL)
918 catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
921 for (i = 0; i < ndir; i++)
922 catch_command_errors (directory_switch, dirarg[i], 0, RETURN_MASK_ALL);
923 xfree (dirarg);
925 /* Skip auto-loading section-specified scripts until we've sourced
926 local_gdbinit (which is often used to augment the source search
927 path). */
928 save_auto_load = global_auto_load;
929 global_auto_load = 0;
931 if (execarg != NULL
932 && symarg != NULL
933 && strcmp (execarg, symarg) == 0)
935 /* The exec file and the symbol-file are the same. If we can't
936 open it, better only print one error message.
937 catch_command_errors returns non-zero on success! */
938 if (catch_command_errors (exec_file_attach, execarg,
939 !batch_flag, RETURN_MASK_ALL))
940 catch_command_errors (symbol_file_add_main, symarg,
941 !batch_flag, RETURN_MASK_ALL);
943 else
945 if (execarg != NULL)
946 catch_command_errors (exec_file_attach, execarg,
947 !batch_flag, RETURN_MASK_ALL);
948 if (symarg != NULL)
949 catch_command_errors (symbol_file_add_main, symarg,
950 !batch_flag, RETURN_MASK_ALL);
953 if (corearg && pidarg)
954 error (_("Can't attach to process and specify "
955 "a core file at the same time."));
957 if (corearg != NULL)
958 catch_command_errors (core_file_command, corearg,
959 !batch_flag, RETURN_MASK_ALL);
960 else if (pidarg != NULL)
961 catch_command_errors (attach_command, pidarg,
962 !batch_flag, RETURN_MASK_ALL);
963 else if (pid_or_core_arg)
965 /* The user specified 'gdb program pid' or gdb program core'.
966 If pid_or_core_arg's first character is a digit, try attach
967 first and then corefile. Otherwise try just corefile. */
969 if (isdigit (pid_or_core_arg[0]))
971 if (catch_command_errors (attach_command, pid_or_core_arg,
972 !batch_flag, RETURN_MASK_ALL) == 0)
973 catch_command_errors (core_file_command, pid_or_core_arg,
974 !batch_flag, RETURN_MASK_ALL);
976 else /* Can't be a pid, better be a corefile. */
977 catch_command_errors (core_file_command, pid_or_core_arg,
978 !batch_flag, RETURN_MASK_ALL);
981 if (ttyarg != NULL)
982 set_inferior_io_terminal (ttyarg);
984 /* Error messages should no longer be distinguished with extra output. */
985 error_pre_print = NULL;
986 quit_pre_print = NULL;
987 warning_pre_print = _("warning: ");
989 /* Read the .gdbinit file in the current directory, *if* it isn't
990 the same as the $HOME/.gdbinit file (it should exist, also). */
991 if (local_gdbinit)
993 auto_load_local_gdbinit_pathname = gdb_realpath (local_gdbinit);
995 if (!inhibit_gdbinit && auto_load_local_gdbinit
996 && file_is_auto_load_safe (local_gdbinit,
997 _("auto-load: Loading .gdbinit "
998 "file \"%s\".\n"),
999 local_gdbinit))
1001 auto_load_local_gdbinit_loaded = 1;
1003 catch_command_errors (source_script, local_gdbinit, 0,
1004 RETURN_MASK_ALL);
1008 /* Now that all .gdbinit's have been read and all -d options have been
1009 processed, we can read any scripts mentioned in SYMARG.
1010 We wait until now because it is common to add to the source search
1011 path in local_gdbinit. */
1012 global_auto_load = save_auto_load;
1013 ALL_OBJFILES (objfile)
1014 load_auto_scripts_for_objfile (objfile);
1016 /* Process '-x' and '-ex' options. */
1017 for (i = 0; VEC_iterate (cmdarg_s, cmdarg_vec, i, cmdarg_p); i++)
1018 switch (cmdarg_p->type)
1020 case CMDARG_FILE:
1021 catch_command_errors (source_script, cmdarg_p->string,
1022 !batch_flag, RETURN_MASK_ALL);
1023 break;
1024 case CMDARG_COMMAND:
1025 catch_command_errors (execute_command, cmdarg_p->string,
1026 !batch_flag, RETURN_MASK_ALL);
1027 break;
1030 /* Read in the old history after all the command files have been
1031 read. */
1032 init_history ();
1034 if (batch_flag)
1036 /* We have hit the end of the batch file. */
1037 quit_force (NULL, 0);
1040 /* Show time and/or space usage. */
1041 do_cleanups (pre_stat_chain);
1043 /* NOTE: cagney/1999-11-07: There is probably no reason for not
1044 moving this loop and the code found in captured_command_loop()
1045 into the command_loop() proper. The main thing holding back that
1046 change - SET_TOP_LEVEL() - has been eliminated. */
1047 while (1)
1049 catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
1051 /* No exit -- exit is through quit_command. */
1055 gdb_main (struct captured_main_args *args)
1057 kernel_debugger = 0;
1058 use_windows = args->use_windows;
1059 catch_errors (captured_main, args, "", RETURN_MASK_ALL);
1060 /* The only way to end up here is by an error (normal exit is
1061 handled by quit_force()), hence always return an error status. */
1062 return 1;
1066 /* Don't use *_filtered for printing help. We don't want to prompt
1067 for continue no matter how small the screen or how much we're going
1068 to print. */
1070 static void
1071 print_gdb_help (struct ui_file *stream)
1073 char *system_gdbinit;
1074 char *home_gdbinit;
1075 char *local_gdbinit;
1077 get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
1079 fputs_unfiltered (_("\
1080 This is the GNU debugger. Usage:\n\n\
1081 gdb [options] [executable-file [core-file or process-id]]\n\
1082 gdb [options] --args executable-file [inferior-arguments ...]\n\n\
1083 Options:\n\n\
1084 "), stream);
1085 fputs_unfiltered (_("\
1086 --args Arguments after executable-file are passed to inferior\n\
1087 "), stream);
1088 fputs_unfiltered (_("\
1089 -b BAUDRATE Set serial port baud rate used for remote debugging.\n\
1090 --batch Exit after processing options.\n\
1091 --batch-silent As for --batch, but suppress all gdb stdout output.\n\
1092 --return-child-result\n\
1093 GDB exit code will be the child's exit code.\n\
1094 --cd=DIR Change current directory to DIR.\n\
1095 --command=FILE, -x Execute GDB commands from FILE.\n\
1096 --eval-command=COMMAND, -ex\n\
1097 Execute a single GDB command.\n\
1098 May be used multiple times and in conjunction\n\
1099 with --command.\n\
1100 --init-command=FILE, -ix Like -x but execute it before loading inferior.\n\
1101 --init-eval-command=COMMAND, -iex Like -ex but before loading inferior.\n\
1102 --core=COREFILE Analyze the core dump COREFILE.\n\
1103 --pid=PID Attach to running process PID.\n\
1104 "), stream);
1105 fputs_unfiltered (_("\
1106 --dbx DBX compatibility mode.\n\
1107 --directory=DIR Search for source files in DIR.\n\
1108 --exec=EXECFILE Use EXECFILE as the executable.\n\
1109 --fullname Output information used by emacs-GDB interface.\n\
1110 --help Print this message.\n\
1111 "), stream);
1112 fputs_unfiltered (_("\
1113 --interpreter=INTERP\n\
1114 Select a specific interpreter / user interface\n\
1115 "), stream);
1116 fputs_unfiltered (_("\
1117 -l TIMEOUT Set timeout in seconds for remote debugging.\n\
1118 --nw Do not use a window interface.\n\
1119 --nx Do not read any "), stream);
1120 fputs_unfiltered (gdbinit, stream);
1121 fputs_unfiltered (_(" files.\n\
1122 --nh Do not read "), stream);
1123 fputs_unfiltered (gdbinit, stream);
1124 fputs_unfiltered (_(" file from home directory.\n\
1125 --quiet Do not print version number on startup.\n\
1126 --readnow Fully read symbol files on first access.\n\
1127 "), stream);
1128 fputs_unfiltered (_("\
1129 --se=FILE Use FILE as symbol file and executable file.\n\
1130 --symbols=SYMFILE Read symbols from SYMFILE.\n\
1131 --tty=TTY Use TTY for input/output by the program being debugged.\n\
1132 "), stream);
1133 #if defined(TUI)
1134 fputs_unfiltered (_("\
1135 --tui Use a terminal user interface.\n\
1136 "), stream);
1137 #endif
1138 fputs_unfiltered (_("\
1139 --version Print version information and then exit.\n\
1140 -w Use a window interface.\n\
1141 --write Set writing into executable and core files.\n\
1142 --xdb XDB compatibility mode.\n\
1143 "), stream);
1144 fputs_unfiltered (_("\n\
1145 At startup, GDB reads the following init files and executes their commands:\n\
1146 "), stream);
1147 if (system_gdbinit)
1148 fprintf_unfiltered (stream, _("\
1149 * system-wide init file: %s\n\
1150 "), system_gdbinit);
1151 if (home_gdbinit)
1152 fprintf_unfiltered (stream, _("\
1153 * user-specific init file: %s\n\
1154 "), home_gdbinit);
1155 if (local_gdbinit)
1156 fprintf_unfiltered (stream, _("\
1157 * local init file (see also 'set auto-load local-gdbinit'): ./%s\n\
1158 "), local_gdbinit);
1159 fputs_unfiltered (_("\n\
1160 For more information, type \"help\" from within GDB, or consult the\n\
1161 GDB manual (available as on-line info or a printed manual).\n\
1162 "), stream);
1163 if (REPORT_BUGS_TO[0] && stream == gdb_stdout)
1164 fprintf_unfiltered (stream, _("\
1165 Report bugs to \"%s\".\n\
1166 "), REPORT_BUGS_TO);