1 /* Top level stuff for GDB, the GNU debugger.
2
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "defs.h"
21 #include "top.h"
22 #include "target.h"
23 #include "inferior.h"
24 #include "symfile.h"
25 #include "gdbcore.h"
26
27 #include "exceptions.h"
28 #include "getopt.h"
29
30 #include <sys/types.h>
31 #include "gdb_stat.h"
32 #include <ctype.h>
33
34 #include "gdb_string.h"
35 #include "event-loop.h"
36 #include "ui-out.h"
37
38 #include "interps.h"
39 #include "main.h"
40 #include "source.h"
41 #include "cli/cli-cmds.h"
42 #include "python/python.h"
43 #include "objfiles.h"
44 #include "auto-load.h"
45
46 #include "filenames.h"
47
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;
52
53 /* Whether xdb commands will be handled. */
54 int xdb_commands = 0;
55
56 /* Whether dbx commands will be handled. */
57 int dbx_commands = 0;
58
59 /* System root path, used to find libraries etc. */
60 char *gdb_sysroot = 0;
61
62 /* GDB datadir, used to store data files. */
63 char *gdb_datadir = 0;
64
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;
69
70 /* If gdb was configured with --with-python=/path,
71 the possibly relocated path to python's lib directory. */
72 char *python_libdir = 0;
73
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;
82
83 /* True if --batch or --batch-silent was seen. */
84 int batch_flag = 0;
85
86 /* Support for the --batch-silent option. */
87 int batch_silent = 0;
88
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;
94
95
96 /* GDB as it has been invoked from the command line (i.e. argv[0]). */
97 static char *gdb_program_name;
98
99 /* DragonFly kgdb support */
100 int kernel_debugger;
101
102 static void print_gdb_help (struct ui_file *);
103
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. */
109
110 static char *
relocate_path(const char * progname,const char * initial,int flag)111 relocate_path (const char *progname, const char *initial, int flag)
112 {
113 if (flag)
114 return make_relative_prefix (progname, BINDIR, initial);
115 return xstrdup (initial);
116 }
117
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. */
123
124 char *
relocate_gdb_directory(const char * initial,int flag)125 relocate_gdb_directory (const char *initial, int flag)
126 {
127 char *dir;
128
129 dir = relocate_path (gdb_program_name, initial, flag);
130 if (dir)
131 {
132 struct stat s;
133
134 if (*dir == '\0' || stat (dir, &s) != 0 || !S_ISDIR (s.st_mode))
135 {
136 xfree (dir);
137 dir = NULL;
138 }
139 }
140 if (!dir)
141 dir = xstrdup (initial);
142
143 /* Canonicalize the directory. */
144 if (*dir)
145 {
146 char *canon_sysroot = lrealpath (dir);
147
148 if (canon_sysroot)
149 {
150 xfree (dir);
151 dir = canon_sysroot;
152 }
153 }
154
155 return dir;
156 }
157
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
get_init_files(char ** system_gdbinit,char ** home_gdbinit,char ** local_gdbinit)164 get_init_files (char **system_gdbinit,
165 char **home_gdbinit,
166 char **local_gdbinit)
167 {
168 static char *sysgdbinit = NULL;
169 static char *homeinit = NULL;
170 static char *localinit = NULL;
171 static int initialized = 0;
172
173 if (!initialized)
174 {
175 struct stat homebuf, cwdbuf, s;
176 char *homedir;
177
178 if (SYSTEM_GDBINIT[0])
179 {
180 int datadir_len = strlen (GDB_DATADIR);
181 int sys_gdbinit_len = strlen (SYSTEM_GDBINIT);
182 char *relocated_sysgdbinit;
183
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]))
190 {
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;
195
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);
201 }
202 else
203 {
204 relocated_sysgdbinit = relocate_path (gdb_program_name,
205 SYSTEM_GDBINIT,
206 SYSTEM_GDBINIT_RELOCATABLE);
207 }
208 if (relocated_sysgdbinit && stat (relocated_sysgdbinit, &s) == 0)
209 sysgdbinit = relocated_sysgdbinit;
210 else
211 xfree (relocated_sysgdbinit);
212 }
213
214 homedir = getenv ("HOME");
215
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). */
221
222 memset (&homebuf, 0, sizeof (struct stat));
223 memset (&cwdbuf, 0, sizeof (struct stat));
224
225 if (homedir)
226 {
227 homeinit = xstrprintf ("%s/%s", homedir, gdbinit);
228 if (stat (homeinit, &homebuf) != 0)
229 {
230 xfree (homeinit);
231 homeinit = NULL;
232 }
233 }
234
235 if (stat (gdbinit, &cwdbuf) == 0)
236 {
237 if (!homeinit
238 || memcmp ((char *) &homebuf, (char *) &cwdbuf,
239 sizeof (struct stat)))
240 localinit = gdbinit;
241 }
242
243 initialized = 1;
244 }
245
246 *system_gdbinit = sysgdbinit;
247 *home_gdbinit = homeinit;
248 *local_gdbinit = localinit;
249 }
250
251 /* Call command_loop. If it happens to return, pass that through as a
252 non-zero return status. */
253
254 static int
captured_command_loop(void * data)255 captured_command_loop (void *data)
256 {
257 /* Top-level execution commands can be run on the background from
258 here on. */
259 interpreter_async = 1;
260
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;
276 }
277
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,
284
285 /* Option type -ex. */
286 CMDARG_COMMAND,
287
288 /* Option type -ix. */
289 CMDARG_INIT_FILE,
290
291 /* Option type -iex. */
292 CMDARG_INIT_COMMAND
293 } type;
294
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;
299
300 /* Define type VEC (cmdarg_s). */
301 DEF_VEC_O (cmdarg_s);
302
303 static int
captured_main(void * data)304 captured_main (void *data)
305 {
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;
312
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;
321
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;
326
327 /* Pointers to all arguments of --command option. */
328 VEC (cmdarg_s) *cmdarg_vec = NULL;
329 struct cmdarg *cmdarg_p;
330
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;
337
338 /* gdb init files. */
339 char *system_gdbinit;
340 char *home_gdbinit;
341 char *local_gdbinit;
342
343 int i;
344 int save_auto_load;
345 struct objfile *objfile;
346
347 struct cleanup *pre_stat_chain;
348
349 #ifdef HAVE_SBRK
350 /* Set this before calling make_command_stats_cleanup. */
351 lim_at_start = (char *) sbrk (0);
352 #endif
353
354 pre_stat_chain = make_command_stats_cleanup (0);
355
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);
364
365 bfd_init ();
366
367 make_cleanup (VEC_cleanup (cmdarg_s), &cmdarg_vec);
368 dirsize = 1;
369 dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
370 ndir = 0;
371
372 clear_quit_flag ();
373 saved_command_line = (char *) xmalloc (saved_command_line_size);
374 saved_command_line[0] = '\0';
375 instream = stdin;
376
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 */
384
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
392
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));
400
401 current_directory = gdb_dirbuf;
402
403 /* Set the sysroot path. */
404 gdb_sysroot = relocate_gdb_directory (TARGET_SYSTEM_ROOT,
405 TARGET_SYSTEM_ROOT_RELOCATABLE);
406
407 debug_file_directory = relocate_gdb_directory (DEBUGDIR,
408 DEBUGDIR_RELOCATABLE);
409
410 gdb_datadir = relocate_gdb_directory (GDB_DATADIR,
411 GDB_DATADIR_RELOCATABLE);
412
413 #ifdef WITH_PYTHON_PATH
414 {
415 /* For later use in helping Python find itself. */
416 char *tmp = concat (WITH_PYTHON_PATH, SLASH_STRING, "lib", NULL);
417
418 python_libdir = relocate_gdb_directory (tmp, PYTHON_PATH_RELOCATABLE);
419 xfree (tmp);
420 }
421 #endif
422
423 #ifdef RELOC_SRCDIR
424 add_substitute_path_rule (RELOC_SRCDIR,
425 make_relative_prefix (gdb_program_name, BINDIR,
426 RELOC_SRCDIR));
427 #endif
428
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);
434
435 /* Parse arguments and options. */
436 {
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
452 };
453 static struct option long_options[] =
454 {
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},
468
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'},
474
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}
521 };
522
523 while (1)
524 {
525 int option_index;
526
527 c = getopt_long_only (argc, argv, "",
528 long_options, &option_index);
529 if (c == EOF || set_args)
530 break;
531
532 /* Long option that takes an argument. */
533 if (c == 0 && long_options[option_index].flag == 0)
534 c = long_options[option_index].val;
535
536 switch (c)
537 {
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':
607 {
608 struct cmdarg cmdarg = { CMDARG_FILE, optarg };
609
610 VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
611 }
612 break;
613 case 'X':
614 {
615 struct cmdarg cmdarg = { CMDARG_COMMAND, optarg };
616
617 VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
618 }
619 break;
620 case OPT_IX:
621 {
622 struct cmdarg cmdarg = { CMDARG_INIT_FILE, optarg };
623
624 VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
625 }
626 break;
627 case OPT_IEX:
628 {
629 struct cmdarg cmdarg = { CMDARG_INIT_COMMAND, optarg };
630
631 VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
632 }
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':
645 {
646 extern int gdbtk_test (char *);
647
648 if (!gdbtk_test (optarg))
649 {
650 fprintf_unfiltered (gdb_stderr,
651 _("%s: unable to load "
652 "tclcommand file \"%s\""),
653 argv[0], optarg);
654 exit (1);
655 }
656 break;
657 }
658 case 'y':
659 /* Backwards compatibility only. */
660 break;
661 case 'w':
662 {
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;
666
667 external_editor_command = xstrdup (optarg);
668 break;
669 }
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)
678 {
679 dirsize *= 2;
680 dirarg = (char **) xrealloc ((char *) dirarg,
681 dirsize * sizeof (*dirarg));
682 }
683 break;
684 case 't':
685 ttyarg = optarg;
686 break;
687 case 'q':
688 quiet = 1;
689 break;
690 case 'b':
691 {
692 int i;
693 char *p;
694
695 i = strtol (optarg, &p, 0);
696 if (i == 0 && p == optarg)
697
698 /* Don't use *_filtered or warning() (which relies on
699 current_target) until after initialize_all_files(). */
700
701 fprintf_unfiltered
702 (gdb_stderr,
703 _("warning: could not set baud rate to `%s'.\n"), optarg);
704 else
705 baud_rate = i;
706 }
707 break;
708 case 'l':
709 {
710 int i;
711 char *p;
712
713 i = strtol (optarg, &p, 0);
714 if (i == 0 && p == optarg)
715
716 /* Don't use *_filtered or warning() (which relies on
717 current_target) until after initialize_all_files(). */
718
719 fprintf_unfiltered (gdb_stderr,
720 _("warning: could not set "
721 "timeout limit to `%s'.\n"), optarg);
722 else
723 remote_timeout = i;
724 }
725 break;
726
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);
733 }
734 }
735
736 /* If --help or --version, disable window interface. */
737 if (print_help || print_version)
738 {
739 use_windows = 0;
740 }
741
742 if (batch_flag)
743 quiet = 1;
744 }
745
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);
749
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)
753 {
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)
758 {
759 fprintf_unfiltered (gdb_stderr,
760 _("%s: `--args' specified but "
761 "no program specified\n"),
762 argv[0]);
763 exit (1);
764 }
765 symarg = argv[optind];
766 execarg = argv[optind];
767 ++optind;
768 set_inferior_args_vector (argc - optind, &argv[optind]);
769 }
770 else
771 {
772 /* OK, that's all the options. */
773
774 /* The first argument, if specified, is the name of the
775 executable. */
776 if (optind < argc)
777 {
778 symarg = argv[optind];
779 execarg = argv[optind];
780 optind++;
781 }
782
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)
788 {
789 pid_or_core_arg = argv[optind];
790 optind++;
791 }
792
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) ? "" : " ...");
801 }
802
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);
807
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. */
812
813 if (print_version)
814 {
815 print_gdb_version (gdb_stdout);
816 wrap_here ("");
817 printf_filtered ("\n");
818 exit (0);
819 }
820
821 if (print_help)
822 {
823 print_gdb_help (gdb_stdout);
824 fputs_unfiltered ("\n", gdb_stdout);
825 exit (0);
826 }
827
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)
833 {
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. */
843 }
844
845 /* Install the default UI. All the interpreters should have had a
846 look at things by now. Initialize the default interpreter. */
847
848 {
849 /* Find it. */
850 struct interp *interp = interp_lookup (interpreter_p);
851
852 if (interp == NULL)
853 error (_("Interpreter `%s' unrecognized"), interpreter_p);
854 /* Install it. */
855 if (!interp_set (interp, 1))
856 {
857 fprintf_unfiltered (gdb_stderr,
858 "Interpreter `%s' failed to initialize.\n",
859 interpreter_p);
860 exit (1);
861 }
862 }
863
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))
869 {
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. */
879 }
880
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: ");
885
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);
892
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. */
897
898 if (home_gdbinit && !inhibit_gdbinit && !inhibit_home_gdbinit)
899 catch_command_errors (source_script, home_gdbinit, 0, RETURN_MASK_ALL);
900
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)
904 {
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;
913 }
914
915 /* Now perform all the actions indicated by the arguments. */
916 if (cdarg != NULL)
917 {
918 catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
919 }
920
921 for (i = 0; i < ndir; i++)
922 catch_command_errors (directory_switch, dirarg[i], 0, RETURN_MASK_ALL);
923 xfree (dirarg);
924
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;
930
931 if (execarg != NULL
932 && symarg != NULL
933 && strcmp (execarg, symarg) == 0)
934 {
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);
942 }
943 else
944 {
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);
951 }
952
953 if (corearg && pidarg)
954 error (_("Can't attach to process and specify "
955 "a core file at the same time."));
956
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)
964 {
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. */
968
969 if (isdigit (pid_or_core_arg[0]))
970 {
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);
975 }
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);
979 }
980
981 if (ttyarg != NULL)
982 set_inferior_io_terminal (ttyarg);
983
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: ");
988
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)
992 {
993 auto_load_local_gdbinit_pathname = gdb_realpath (local_gdbinit);
994
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))
1000 {
1001 auto_load_local_gdbinit_loaded = 1;
1002
1003 catch_command_errors (source_script, local_gdbinit, 0,
1004 RETURN_MASK_ALL);
1005 }
1006 }
1007
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);
1015
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)
1019 {
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;
1028 }
1029
1030 /* Read in the old history after all the command files have been
1031 read. */
1032 init_history ();
1033
1034 if (batch_flag)
1035 {
1036 /* We have hit the end of the batch file. */
1037 quit_force (NULL, 0);
1038 }
1039
1040 /* Show time and/or space usage. */
1041 do_cleanups (pre_stat_chain);
1042
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)
1048 {
1049 catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
1050 }
1051 /* No exit -- exit is through quit_command. */
1052 }
1053
1054 int
gdb_main(struct captured_main_args * args)1055 gdb_main (struct captured_main_args *args)
1056 {
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;
1063 }
1064
1065
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. */
1069
1070 static void
print_gdb_help(struct ui_file * stream)1071 print_gdb_help (struct ui_file *stream)
1072 {
1073 char *system_gdbinit;
1074 char *home_gdbinit;
1075 char *local_gdbinit;
1076
1077 get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
1078
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);
1167 }
1168