GDB (xrefs)

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