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