GDB (xrefs)
Loading...
Searching...
No Matches
/tmp/gdb-13.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-2023 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 "gdbsupport/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 "gdbsupport/filestuff.h"
44#include <signal.h>
45#include "event-top.h"
46#include "infrun.h"
47#include "gdbsupport/signals-state-save-restore.h"
48#include <algorithm>
49#include <vector>
50#include "gdbsupport/pathstuff.h"
51#include "cli/cli-style.h"
52#ifdef GDBTK
53#include "gdbtk/generic/gdbtk.h"
54#endif
55#include "gdbsupport/alt-stack.h"
56#include "observable.h"
57#include "serial.h"
58
59/* The selected interpreter. */
60std::string interpreter_p;
61
62/* System root path, used to find libraries etc. */
63std::string gdb_sysroot;
64
65/* GDB datadir, used to store data files. */
66std::string gdb_datadir;
67
68/* Non-zero if GDB_DATADIR was provided on the command line.
69 This doesn't track whether data-directory is set later from the
70 command line, but we don't reread system.gdbinit when that happens. */
71static int gdb_datadir_provided = 0;
72
73/* If gdb was configured with --with-python=/path,
74 the possibly relocated path to python's lib directory. */
75std::string python_libdir;
76
77/* Target IO streams. */
81
82/* True if --batch or --batch-silent was seen. */
83int batch_flag = 0;
84
85/* Support for the --batch-silent option. */
87
88/* Support for --return-child-result option.
89 Set the default to -1 to return error in the case
90 that the program does not run or does not complete. */
93
94
95/* GDB as it has been invoked from the command line (i.e. argv[0]). */
96static char *gdb_program_name;
97
98/* Return read only pointer to GDB_PROGRAM_NAME. */
99const char *
101{
102 return gdb_program_name;
103}
104
105static void print_gdb_help (struct ui_file *);
106
107/* Set the data-directory parameter to NEW_DATADIR.
108 If NEW_DATADIR is not a directory then a warning is printed.
109 We don't signal an error for backward compatibility. */
110
111void
112set_gdb_data_directory (const char *new_datadir)
113{
114 struct stat st;
115
116 if (stat (new_datadir, &st) < 0)
117 {
118 int save_errno = errno;
119
120 gdb_printf (gdb_stderr, "Warning: ");
121 print_sys_errmsg (new_datadir, save_errno);
122 }
123 else if (!S_ISDIR (st.st_mode))
124 warning (_("%ps is not a directory."),
125 styled_string (file_name_style.style (), new_datadir));
126
127 gdb_datadir = gdb_realpath (new_datadir).get ();
128
129 /* gdb_realpath won't return an absolute path if the path doesn't exist,
130 but we still want to record an absolute path here. If the user entered
131 "../foo" and "../foo" doesn't exist then we'll record $(pwd)/../foo which
132 isn't canonical, but that's ok. */
133 if (!IS_ABSOLUTE_PATH (gdb_datadir.c_str ()))
134 gdb_datadir = gdb_abspath (gdb_datadir.c_str ());
135}
136
137/* Relocate a file or directory. PROGNAME is the name by which gdb
138 was invoked (i.e., argv[0]). INITIAL is the default value for the
139 file or directory. RELOCATABLE is true if the value is relocatable,
140 false otherwise. This may return an empty string under the same
141 conditions as make_relative_prefix returning NULL. */
142
143static std::string
144relocate_path (const char *progname, const char *initial, bool relocatable)
145{
146 if (relocatable)
147 {
148 gdb::unique_xmalloc_ptr<char> str (make_relative_prefix (progname,
149 BINDIR,
150 initial));
151 if (str != nullptr)
152 return str.get ();
153 return std::string ();
154 }
155 return initial;
156}
157
158/* Like relocate_path, but specifically checks for a directory.
159 INITIAL is relocated according to the rules of relocate_path. If
160 the result is a directory, it is used; otherwise, INITIAL is used.
161 The chosen directory is then canonicalized using lrealpath. */
162
163std::string
164relocate_gdb_directory (const char *initial, bool relocatable)
165{
166 std::string dir = relocate_path (gdb_program_name, initial, relocatable);
167 if (!dir.empty ())
168 {
169 struct stat s;
170
171 if (stat (dir.c_str (), &s) != 0 || !S_ISDIR (s.st_mode))
172 {
173 dir.clear ();
174 }
175 }
176 if (dir.empty ())
177 dir = initial;
178
179 /* Canonicalize the directory. */
180 if (!dir.empty ())
181 {
182 gdb::unique_xmalloc_ptr<char> canon_sysroot (lrealpath (dir.c_str ()));
183
184 if (canon_sysroot)
185 dir = canon_sysroot.get ();
186 }
187
188 return dir;
189}
190
191/* Given a gdbinit path in FILE, adjusts it according to the gdb_datadir
192 parameter if it is in the data dir, or passes it through relocate_path
193 otherwise. */
194
195static std::string
196relocate_file_path_maybe_in_datadir (const std::string &file,
197 bool relocatable)
198{
199 size_t datadir_len = strlen (GDB_DATADIR);
200
201 std::string relocated_path;
202
203 /* If SYSTEM_GDBINIT lives in data-directory, and data-directory
204 has been provided, search for SYSTEM_GDBINIT there. */
206 && datadir_len < file.length ()
207 && filename_ncmp (file.c_str (), GDB_DATADIR, datadir_len) == 0
208 && IS_DIR_SEPARATOR (file[datadir_len]))
209 {
210 /* Append the part of SYSTEM_GDBINIT that follows GDB_DATADIR
211 to gdb_datadir. */
212
213 size_t start = datadir_len;
214 for (; IS_DIR_SEPARATOR (file[start]); ++start)
215 ;
216 relocated_path = gdb_datadir + SLASH_STRING + file.substr (start);
217 }
218 else
219 {
220 relocated_path = relocate_path (gdb_program_name, file.c_str (),
221 relocatable);
222 }
223 return relocated_path;
224}
225
226/* A class to wrap up the logic for finding the three different types of
227 initialisation files GDB uses, system wide, home directory, and current
228 working directory. */
229
231{
232public:
233 /* Constructor. Finds initialisation files named FILENAME in the home
234 directory or local (current working) directory. System initialisation
235 files are found in both SYSTEM_FILENAME and SYSTEM_DIRNAME if these
236 are not nullptr (either or both can be). The matching *_RELOCATABLE
237 flag is passed through to RELOCATE_FILE_PATH_MAYBE_IN_DATADIR.
238
239 If FILENAME starts with a '.' then when looking in the home directory
240 this first '.' can be ignored in some cases. */
241 explicit gdb_initfile_finder (const char *filename,
242 const char *system_filename,
243 bool system_filename_relocatable,
244 const char *system_dirname,
245 bool system_dirname_relocatable,
246 bool lookup_local_file)
247 {
248 struct stat s;
249
250 if (system_filename != nullptr && system_filename[0] != '\0')
251 {
252 std::string relocated_filename
253 = relocate_file_path_maybe_in_datadir (system_filename,
254 system_filename_relocatable);
255 if (!relocated_filename.empty ()
256 && stat (relocated_filename.c_str (), &s) == 0)
257 m_system_files.push_back (relocated_filename);
258 }
259
260 if (system_dirname != nullptr && system_dirname[0] != '\0')
261 {
262 std::string relocated_dirname
263 = relocate_file_path_maybe_in_datadir (system_dirname,
264 system_dirname_relocatable);
265 if (!relocated_dirname.empty ())
266 {
267 gdb_dir_up dir (opendir (relocated_dirname.c_str ()));
268 if (dir != nullptr)
269 {
270 std::vector<std::string> files;
271 while (true)
272 {
273 struct dirent *ent = readdir (dir.get ());
274 if (ent == nullptr)
275 break;
276 std::string name (ent->d_name);
277 if (name == "." || name == "..")
278 continue;
279 /* ent->d_type is not available on all systems
280 (e.g. mingw, Solaris), so we have to call stat(). */
281 std::string tmp_filename
282 = relocated_dirname + SLASH_STRING + name;
283 if (stat (tmp_filename.c_str (), &s) != 0
284 || !S_ISREG (s.st_mode))
285 continue;
286 const struct extension_language_defn *extlang
287 = get_ext_lang_of_file (tmp_filename.c_str ());
288 /* We effectively don't support "set script-extension
289 off/soft", because we are loading system init files
290 here, so it does not really make sense to depend on
291 a setting. */
292 if (extlang != nullptr && ext_lang_present_p (extlang))
293 files.push_back (std::move (tmp_filename));
294 }
295 std::sort (files.begin (), files.end ());
296 m_system_files.insert (m_system_files.end (),
297 files.begin (), files.end ());
298 }
299 }
300 }
301
302 /* If the .gdbinit file in the current directory is the same as
303 the $HOME/.gdbinit file, it should not be sourced. homebuf
304 and cwdbuf are used in that purpose. Make sure that the stats
305 are zero in case one of them fails (this guarantees that they
306 won't match if either exists). */
307
308 struct stat homebuf, cwdbuf;
309 memset (&homebuf, 0, sizeof (struct stat));
310 memset (&cwdbuf, 0, sizeof (struct stat));
311
312 m_home_file = find_gdb_home_config_file (filename, &homebuf);
313
314 if (lookup_local_file && stat (filename, &cwdbuf) == 0)
315 {
316 if (m_home_file.empty ()
317 || memcmp ((char *) &homebuf, (char *) &cwdbuf,
318 sizeof (struct stat)))
319 m_local_file = filename;
320 }
321 }
322
324
325 /* Return a list of system initialisation files. The list could be
326 empty. */
327 const std::vector<std::string> &system_files () const
328 { return m_system_files; }
329
330 /* Return the path to the home initialisation file. The string can be
331 empty if there is no such file. */
332 const std::string &home_file () const
333 { return m_home_file; }
334
335 /* Return the path to the local initialisation file. The string can be
336 empty if there is no such file. */
337 const std::string &local_file () const
338 { return m_local_file; }
339
340private:
341
342 /* Vector of all system init files in the order they should be processed.
343 Could be empty. */
344 std::vector<std::string> m_system_files;
345
346 /* Initialization file from the home directory. Could be the empty
347 string if there is no such file found. */
348 std::string m_home_file;
349
350 /* Initialization file from the current working directory. Could be the
351 empty string if there is no such file found. */
352 std::string m_local_file;
353};
354
355/* Compute the locations of init files that GDB should source and return
356 them in SYSTEM_GDBINIT, HOME_GDBINIT, LOCAL_GDBINIT. The SYSTEM_GDBINIT
357 can be returned as an empty vector, and HOME_GDBINIT and LOCAL_GDBINIT
358 can be returned as empty strings if there is no init file of that
359 type. */
360
361static void
362get_init_files (std::vector<std::string> *system_gdbinit,
363 std::string *home_gdbinit,
364 std::string *local_gdbinit)
365{
366 /* Cache the file lookup object so we only actually search for the files
367 once. */
368 static gdb::optional<gdb_initfile_finder> init_files;
369 if (!init_files.has_value ())
372 true);
373
374 *system_gdbinit = init_files->system_files ();
375 *home_gdbinit = init_files->home_file ();
376 *local_gdbinit = init_files->local_file ();
377}
378
379/* Compute the location of the early init file GDB should source and return
380 it in HOME_GDBEARLYINIT. HOME_GDBEARLYINIT could be returned as an
381 empty string if there is no early init file found. */
382
383static void
384get_earlyinit_files (std::string *home_gdbearlyinit)
385{
386 /* Cache the file lookup object so we only actually search for the files
387 once. */
388 static gdb::optional<gdb_initfile_finder> init_files;
389 if (!init_files.has_value ())
390 init_files.emplace (GDBEARLYINIT, nullptr, false, nullptr, false, false);
391
392 *home_gdbearlyinit = init_files->home_file ();
393}
394
395/* Start up the event loop. This is the entry point to the event loop
396 from the command loop. */
397
398static void
400{
401 /* Loop until there is nothing to do. This is the entry point to
402 the event loop engine. gdb_do_one_event will process one event
403 for each invocation. It blocks waiting for an event and then
404 processes it. */
405 while (1)
406 {
407 int result = 0;
408
409 try
410 {
411 result = gdb_do_one_event ();
412 }
413 catch (const gdb_exception &ex)
414 {
416
417 /* If any exception escaped to here, we better enable
418 stdin. Otherwise, any command that calls async_disable_stdin,
419 and then throws, will leave stdin inoperable. */
421 {
423 }
424 /* If we long-jumped out of do_one_event, we probably didn't
425 get around to resetting the prompt, which leaves readline
426 in a messed-up state. Reset it here. */
429 /* This call looks bizarre, but it is required. If the user
430 entered a command that caused an error,
431 after_char_processing_hook won't be called from
432 rl_callback_read_char_wrapper. Using a cleanup there
433 won't work, since we want this function to be called
434 after a new prompt is printed. */
436 (*after_char_processing_hook) ();
437 /* Maybe better to set a flag to be checked somewhere as to
438 whether display the prompt or not. */
439 }
440
441 if (result < 0)
442 break;
443 }
444
445 /* We are done with the event loop. There are no more event sources
446 to listen to. So we exit GDB. */
447 return;
448}
449
450/* Call command_loop. */
451
452/* Prevent inlining this function for the benefit of GDB's selftests
453 in the testsuite. Those tests want to run GDB under GDB and stop
454 here. */
455static void captured_command_loop () __attribute__((noinline));
456
457static void
459{
460 struct ui *ui = current_ui;
461
462 /* Top-level execution commands can be run in the background from
463 here on. */
464 current_ui->async = 1;
465
466 /* Give the interpreter a chance to print a prompt, if necessary */
469
470 /* Now it's time to start the event loop. */
472
473 /* If the command_loop returned, normally (rather than threw an
474 error) we try to quit. If the quit is aborted, our caller
475 catches the signal and restarts the command loop. */
477}
478
479/* Handle command errors thrown from within catch_command_errors. */
480
481static int
482handle_command_errors (const struct gdb_exception &e)
483{
484 if (e.reason < 0)
485 {
487
488 /* If any exception escaped to here, we better enable stdin.
489 Otherwise, any command that calls async_disable_stdin, and
490 then throws, will leave stdin inoperable. */
492 return 0;
493 }
494 return 1;
495}
496
497/* Type of the command callback passed to the const
498 catch_command_errors. */
499
500typedef void (catch_command_errors_const_ftype) (const char *, int);
501
502/* Wrap calls to commands run before the event loop is started. */
503
504static int
506 const char *arg, int from_tty,
507 bool do_bp_actions = false)
508{
509 try
510 {
511 int was_sync = current_ui->prompt_state == PROMPT_BLOCKED;
512
513 command (arg, from_tty);
514
516
517 /* Do any commands attached to breakpoint we stopped at. */
518 if (do_bp_actions)
520 }
521 catch (const gdb_exception &e)
522 {
523 return handle_command_errors (e);
524 }
525
526 return 1;
527}
528
529/* Adapter for symbol_file_add_main that translates 'from_tty' to a
530 symfile_add_flags. */
531
532static void
533symbol_file_add_main_adapter (const char *arg, int from_tty)
534{
535 symfile_add_flags add_flags = 0;
536
537 if (from_tty)
538 add_flags |= SYMFILE_VERBOSE;
539
540 symbol_file_add_main (arg, add_flags);
541}
542
543/* Perform validation of the '--readnow' and '--readnever' flags. */
544
545static void
547{
549 {
550 error (_("%s: '--readnow' and '--readnever' cannot be "
551 "specified simultaneously"),
553 }
554}
555
556/* Type of this option. */
558{
559 /* Option type -x. */
561
562 /* Option type -ex. */
564
565 /* Option type -ix. */
567
568 /* Option type -iex. */
570
571 /* Option type -eix. */
573
574 /* Option type -eiex. */
577
578/* Arguments of --command option and its counterpart. */
579struct cmdarg
580{
581 cmdarg (cmdarg_kind type_, char *string_)
582 : type (type_), string (string_)
583 {}
584
585 /* Type of this option. */
587
588 /* Value of this option - filename or the GDB command itself. String memory
589 is not owned by this structure despite it is 'const'. */
590 char *string;
591};
592
593/* From CMDARG_VEC execute command files (matching FILE_TYPE) or commands
594 (matching CMD_TYPE). Update the value in *RET if and scripts or
595 commands are executed. */
596
597static void
598execute_cmdargs (const std::vector<struct cmdarg> *cmdarg_vec,
599 cmdarg_kind file_type, cmdarg_kind cmd_type,
600 int *ret)
601{
602 for (const auto &cmdarg_p : *cmdarg_vec)
603 {
604 if (cmdarg_p.type == file_type)
605 *ret = catch_command_errors (source_script, cmdarg_p.string,
606 !batch_flag);
607 else if (cmdarg_p.type == cmd_type)
608 *ret = catch_command_errors (execute_command, cmdarg_p.string,
609 !batch_flag, true);
610 }
611}
612
613static void
615{
616 int argc = context->argc;
617 char **argv = context->argv;
618
619 static int quiet = 0;
620 static int set_args = 0;
621 static int inhibit_home_gdbinit = 0;
622
623 /* Pointers to various arguments from command line. */
624 char *symarg = NULL;
625 char *execarg = NULL;
626 char *pidarg = NULL;
627 char *corearg = NULL;
628 char *pid_or_core_arg = NULL;
629 char *cdarg = NULL;
630 char *ttyarg = NULL;
631
632 /* These are static so that we can take their address in an
633 initializer. */
634 static int print_help;
635 static int print_version;
636 static int print_configuration;
637
638 /* Pointers to all arguments of --command option. */
639 std::vector<struct cmdarg> cmdarg_vec;
640
641 /* All arguments of --directory option. */
642 std::vector<char *> dirarg;
643
644 int i;
645 int save_auto_load;
646 int ret = 1;
647
648#ifdef HAVE_USEFUL_SBRK
649 /* Set this before constructing scoped_command_stats. */
650 lim_at_start = (char *) sbrk (0);
651#endif
652
653 scoped_command_stats stat_reporter (false);
654
655#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
656 setlocale (LC_MESSAGES, "");
657#endif
658#if defined (HAVE_SETLOCALE)
659 setlocale (LC_CTYPE, "");
660#endif
661#ifdef ENABLE_NLS
662 bindtextdomain (PACKAGE, LOCALEDIR);
663 textdomain (PACKAGE);
664#endif
665
666 notice_open_fds ();
667
668#ifdef __MINGW32__
669 /* Ensure stderr is unbuffered. A Cygwin pty or pipe is implemented
670 as a Windows pipe, and Windows buffers on pipes. */
671 setvbuf (stderr, NULL, _IONBF, BUFSIZ);
672#endif
673
674 /* Note: `error' cannot be called before this point, because the
675 caller will crash when trying to print the exception. */
676 main_ui = new ui (stdin, stdout, stderr);
678
682
683 if (bfd_init () != BFD_INIT_MAGIC)
684 error (_("fatal error: libbfd ABI mismatch"));
685
686#ifdef __MINGW32__
687 /* On Windows, argv[0] is not necessarily set to absolute form when
688 GDB is found along PATH, without which relocation doesn't work. */
690#else
691 gdb_program_name = xstrdup (argv[0]);
692#endif
693
694 /* Prefix warning messages with the command name. */
695 gdb::unique_xmalloc_ptr<char> tmp_warn_preprint
696 = xstrprintf ("%s: warning: ", gdb_program_name);
697 warning_pre_print = tmp_warn_preprint.get ();
698
699 current_directory = getcwd (NULL, 0);
700 if (current_directory == NULL)
701 perror_warning_with_name (_("error finding working directory"));
702
703 /* Set the sysroot path. */
706
707 if (gdb_sysroot.empty ())
709
712
715
716#ifdef WITH_PYTHON_LIBDIR
719#endif
720
721#ifdef RELOC_SRCDIR
722 add_substitute_path_rule (RELOC_SRCDIR,
723 make_relative_prefix (gdb_program_name, BINDIR,
724 RELOC_SRCDIR));
725#endif
726
727 /* There will always be an interpreter. Either the one passed into
728 this captured main, or one specified by the user at start up, or
729 the console. Initialize the interpreter to the one requested by
730 the application. */
731 interpreter_p = context->interpreter_p;
732
733 /* Parse arguments and options. */
734 {
735 int c;
736 /* When var field is 0, use flag field to record the equivalent
737 short option (or arbitrary numbers starting at 10 for those
738 with no equivalent). */
739 enum {
740 OPT_SE = 10,
741 OPT_CD,
742 OPT_ANNOTATE,
743 OPT_STATISTICS,
744 OPT_TUI,
745 OPT_NOWINDOWS,
746 OPT_WINDOWS,
747 OPT_IX,
748 OPT_IEX,
749 OPT_EIX,
750 OPT_EIEX,
751 OPT_READNOW,
752 OPT_READNEVER
753 };
754 /* This struct requires int* in the struct, but write_files is a bool.
755 So use this temporary int that we write back after argument parsing. */
756 int write_files_1 = 0;
757 static struct option long_options[] =
758 {
759 {"tui", no_argument, 0, OPT_TUI},
760 {"readnow", no_argument, NULL, OPT_READNOW},
761 {"readnever", no_argument, NULL, OPT_READNEVER},
762 {"r", no_argument, NULL, OPT_READNOW},
763 {"quiet", no_argument, &quiet, 1},
764 {"q", no_argument, &quiet, 1},
765 {"silent", no_argument, &quiet, 1},
766 {"nh", no_argument, &inhibit_home_gdbinit, 1},
767 {"nx", no_argument, &inhibit_gdbinit, 1},
768 {"n", no_argument, &inhibit_gdbinit, 1},
769 {"batch-silent", no_argument, 0, 'B'},
770 {"batch", no_argument, &batch_flag, 1},
771
772 /* This is a synonym for "--annotate=1". --annotate is now
773 preferred, but keep this here for a long time because people
774 will be running emacses which use --fullname. */
775 {"fullname", no_argument, 0, 'f'},
776 {"f", no_argument, 0, 'f'},
777
778 {"annotate", required_argument, 0, OPT_ANNOTATE},
779 {"help", no_argument, &print_help, 1},
780 {"se", required_argument, 0, OPT_SE},
781 {"symbols", required_argument, 0, 's'},
782 {"s", required_argument, 0, 's'},
783 {"exec", required_argument, 0, 'e'},
784 {"e", required_argument, 0, 'e'},
785 {"core", required_argument, 0, 'c'},
786 {"c", required_argument, 0, 'c'},
787 {"pid", required_argument, 0, 'p'},
788 {"p", required_argument, 0, 'p'},
789 {"command", required_argument, 0, 'x'},
790 {"eval-command", required_argument, 0, 'X'},
791 {"version", no_argument, &print_version, 1},
792 {"configuration", no_argument, &print_configuration, 1},
793 {"x", required_argument, 0, 'x'},
794 {"ex", required_argument, 0, 'X'},
795 {"init-command", required_argument, 0, OPT_IX},
796 {"init-eval-command", required_argument, 0, OPT_IEX},
797 {"ix", required_argument, 0, OPT_IX},
798 {"iex", required_argument, 0, OPT_IEX},
799 {"early-init-command", required_argument, 0, OPT_EIX},
800 {"early-init-eval-command", required_argument, 0, OPT_EIEX},
801 {"eix", required_argument, 0, OPT_EIX},
802 {"eiex", required_argument, 0, OPT_EIEX},
803#ifdef GDBTK
804 {"tclcommand", required_argument, 0, 'z'},
805 {"enable-external-editor", no_argument, 0, 'y'},
806 {"editor-command", required_argument, 0, 'w'},
807#endif
808 {"ui", required_argument, 0, 'i'},
809 {"interpreter", required_argument, 0, 'i'},
810 {"i", required_argument, 0, 'i'},
811 {"directory", required_argument, 0, 'd'},
812 {"d", required_argument, 0, 'd'},
813 {"data-directory", required_argument, 0, 'D'},
814 {"D", required_argument, 0, 'D'},
815 {"cd", required_argument, 0, OPT_CD},
816 {"tty", required_argument, 0, 't'},
817 {"baud", required_argument, 0, 'b'},
818 {"b", required_argument, 0, 'b'},
819 {"nw", no_argument, NULL, OPT_NOWINDOWS},
820 {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
821 {"w", no_argument, NULL, OPT_WINDOWS},
822 {"windows", no_argument, NULL, OPT_WINDOWS},
823 {"statistics", no_argument, 0, OPT_STATISTICS},
824 {"write", no_argument, &write_files_1, 1},
825 {"args", no_argument, &set_args, 1},
826 {"l", required_argument, 0, 'l'},
827 {"return-child-result", no_argument, &return_child_result, 1},
828 {0, no_argument, 0, 0}
829 };
830
831 while (1)
832 {
833 int option_index;
834
835 c = getopt_long_only (argc, argv, "",
836 long_options, &option_index);
837 if (c == EOF || set_args)
838 break;
839
840 /* Long option that takes an argument. */
841 if (c == 0 && long_options[option_index].flag == 0)
842 c = long_options[option_index].val;
843
844 switch (c)
845 {
846 case 0:
847 /* Long option that just sets a flag. */
848 break;
849 case OPT_SE:
850 symarg = optarg;
851 execarg = optarg;
852 break;
853 case OPT_CD:
854 cdarg = optarg;
855 break;
856 case OPT_ANNOTATE:
857 /* FIXME: what if the syntax is wrong (e.g. not digits)? */
858 annotation_level = atoi (optarg);
859 break;
860 case OPT_STATISTICS:
861 /* Enable the display of both time and space usage. */
864 break;
865 case OPT_TUI:
866 /* --tui is equivalent to -i=tui. */
867#ifdef TUI
869#else
870 error (_("%s: TUI mode is not supported"), gdb_program_name);
871#endif
872 break;
873 case OPT_WINDOWS:
874 /* FIXME: cagney/2003-03-01: Not sure if this option is
875 actually useful, and if it is, what it should do. */
876#ifdef GDBTK
877 /* --windows is equivalent to -i=insight. */
879#endif
880 break;
881 case OPT_NOWINDOWS:
882 /* -nw is equivalent to -i=console. */
884 break;
885 case 'f':
887 break;
888 case 's':
889 symarg = optarg;
890 break;
891 case 'e':
892 execarg = optarg;
893 break;
894 case 'c':
895 corearg = optarg;
896 break;
897 case 'p':
898 pidarg = optarg;
899 break;
900 case 'x':
901 cmdarg_vec.emplace_back (CMDARG_FILE, optarg);
902 break;
903 case 'X':
904 cmdarg_vec.emplace_back (CMDARG_COMMAND, optarg);
905 break;
906 case OPT_IX:
907 cmdarg_vec.emplace_back (CMDARG_INIT_FILE, optarg);
908 break;
909 case OPT_IEX:
910 cmdarg_vec.emplace_back (CMDARG_INIT_COMMAND, optarg);
911 break;
912 case OPT_EIX:
913 cmdarg_vec.emplace_back (CMDARG_EARLYINIT_FILE, optarg);
914 break;
915 case OPT_EIEX:
916 cmdarg_vec.emplace_back (CMDARG_EARLYINIT_COMMAND, optarg);
917 break;
918 case 'B':
920 gdb_stdout = new null_file ();
921 break;
922 case 'D':
923 if (optarg[0] == '\0')
924 error (_("%s: empty path for `--data-directory'"),
926 set_gdb_data_directory (optarg);
928 break;
929#ifdef GDBTK
930 case 'z':
931 {
932 if (!gdbtk_test (optarg))
933 error (_("%s: unable to load tclcommand file \"%s\""),
934 gdb_program_name, optarg);
935 break;
936 }
937 case 'y':
938 /* Backwards compatibility only. */
939 break;
940 case 'w':
941 {
942 /* Set the external editor commands when gdb is farming out files
943 to be edited by another program. */
944 external_editor_command = xstrdup (optarg);
945 break;
946 }
947#endif /* GDBTK */
948 case 'i':
949 interpreter_p = optarg;
950 break;
951 case 'd':
952 dirarg.push_back (optarg);
953 break;
954 case 't':
955 ttyarg = optarg;
956 break;
957 case 'q':
958 quiet = 1;
959 break;
960 case 'b':
961 {
962 int rate;
963 char *p;
964
965 rate = strtol (optarg, &p, 0);
966 if (rate == 0 && p == optarg)
967 warning (_("could not set baud rate to `%s'."),
968 optarg);
969 else
970 baud_rate = rate;
971 }
972 break;
973 case 'l':
974 {
975 int timeout;
976 char *p;
977
978 timeout = strtol (optarg, &p, 0);
979 if (timeout == 0 && p == optarg)
980 warning (_("could not set timeout limit to `%s'."),
981 optarg);
982 else
983 remote_timeout = timeout;
984 }
985 break;
986
987 case OPT_READNOW:
988 {
991 }
992 break;
993
994 case OPT_READNEVER:
995 {
998 }
999 break;
1000
1001 case '?':
1002 error (_("Use `%s --help' for a complete list of options."),
1004 }
1005 }
1006 write_files = (write_files_1 != 0);
1007
1008 if (batch_flag)
1009 {
1010 quiet = 1;
1011
1012 /* Disable all output styling when running in batch mode. */
1013 cli_styling = 0;
1014 }
1015 }
1016
1017 save_original_signals_state (quiet);
1018
1019 /* Try to set up an alternate signal stack for SIGSEGV handlers. */
1020 gdb::alternate_signal_stack signal_stack;
1021
1022 /* Initialize all files. */
1023 gdb_init ();
1024
1025 /* Process early init files and early init options from the command line. */
1026 if (!inhibit_gdbinit)
1027 {
1028 std::string home_gdbearlyinit;
1029 get_earlyinit_files (&home_gdbearlyinit);
1030 if (!home_gdbearlyinit.empty () && !inhibit_home_gdbinit)
1032 home_gdbearlyinit.c_str (), 0);
1033 }
1036
1037 /* Initialize the extension languages. */
1039
1040 /* Recheck if we're starting up quietly after processing the startup
1041 scripts and commands. */
1042 if (!quiet)
1043 quiet = check_quiet_mode ();
1044
1045 /* Now that gdb_init has created the initial inferior, we're in
1046 position to set args for that inferior. */
1047 if (set_args)
1048 {
1049 /* The remaining options are the command-line options for the
1050 inferior. The first one is the sym/exec file, and the rest
1051 are arguments. */
1052 if (optind >= argc)
1053 error (_("%s: `--args' specified but no program specified"),
1055
1056 symarg = argv[optind];
1057 execarg = argv[optind];
1058 ++optind;
1059 set_inferior_args_vector (argc - optind, &argv[optind]);
1060 }
1061 else
1062 {
1063 /* OK, that's all the options. */
1064
1065 /* The first argument, if specified, is the name of the
1066 executable. */
1067 if (optind < argc)
1068 {
1069 symarg = argv[optind];
1070 execarg = argv[optind];
1071 optind++;
1072 }
1073
1074 /* If the user hasn't already specified a PID or the name of a
1075 core file, then a second optional argument is allowed. If
1076 present, this argument should be interpreted as either a
1077 PID or a core file, whichever works. */
1078 if (pidarg == NULL && corearg == NULL && optind < argc)
1079 {
1080 pid_or_core_arg = argv[optind];
1081 optind++;
1082 }
1083
1084 /* Any argument left on the command line is unexpected and
1085 will be ignored. Inform the user. */
1086 if (optind < argc)
1088 _("Excess command line "
1089 "arguments ignored. (%s%s)\n"),
1090 argv[optind],
1091 (optind == argc - 1) ? "" : " ...");
1092 }
1093
1094 /* Lookup gdbinit files. Note that the gdbinit file name may be
1095 overridden during file initialization, so get_init_files should be
1096 called after gdb_init. */
1097 std::vector<std::string> system_gdbinit;
1098 std::string home_gdbinit;
1099 std::string local_gdbinit;
1100 get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
1101
1102 /* Do these (and anything which might call wrap_here or *_filtered)
1103 after initialize_all_files() but before the interpreter has been
1104 installed. Otherwize the help/version messages will be eaten by
1105 the interpreter's output handler. */
1106
1107 if (print_version)
1108 {
1110 gdb_printf ("\n");
1111 exit (0);
1112 }
1113
1114 if (print_help)
1115 {
1117 exit (0);
1118 }
1119
1120 if (print_configuration)
1121 {
1123 gdb_printf ("\n");
1124 exit (0);
1125 }
1126
1127 /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
1128 GDB retain the old MI1 interpreter startup behavior. Output the
1129 copyright message before the interpreter is installed. That way
1130 it isn't encapsulated in MI output. */
1131 if (!quiet && interpreter_p == INTERP_MI1)
1132 {
1133 /* Print all the junk at the top, with trailing "..." if we are
1134 about to read a symbol file (possibly slowly). */
1136 if (symarg)
1137 gdb_printf ("..");
1138 gdb_printf ("\n");
1139 gdb_flush (gdb_stdout); /* Force to screen during slow
1140 operations. */
1141 }
1142
1143 /* Install the default UI. All the interpreters should have had a
1144 look at things by now. Initialize the default interpreter. */
1146
1147 /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
1148 GDB retain the old MI1 interpreter startup behavior. Output the
1149 copyright message after the interpreter is installed when it is
1150 any sane interpreter. */
1151 if (!quiet && !current_interp_named_p (INTERP_MI1))
1152 {
1153 /* Print all the junk at the top, with trailing "..." if we are
1154 about to read a symbol file (possibly slowly). */
1156 if (symarg)
1157 gdb_printf ("..");
1158 gdb_printf ("\n");
1159 gdb_flush (gdb_stdout); /* Force to screen during slow
1160 operations. */
1161 }
1162
1163 /* Set off error and warning messages with a blank line. */
1164 tmp_warn_preprint.reset ();
1165 warning_pre_print = _("\nwarning: ");
1166
1167 /* Read and execute the system-wide gdbinit file, if it exists.
1168 This is done *before* all the command line arguments are
1169 processed; it sets global parameters, which are independent of
1170 what file you are debugging or what directory you are in. */
1171 if (!system_gdbinit.empty () && !inhibit_gdbinit)
1172 {
1173 for (const std::string &file : system_gdbinit)
1174 ret = catch_command_errors (source_script, file.c_str (), 0);
1175 }
1176
1177 /* Read and execute $HOME/.gdbinit file, if it exists. This is done
1178 *before* all the command line arguments are processed; it sets
1179 global parameters, which are independent of what file you are
1180 debugging or what directory you are in. */
1181
1182 if (!home_gdbinit.empty () && !inhibit_gdbinit && !inhibit_home_gdbinit)
1183 ret = catch_command_errors (source_script, home_gdbinit.c_str (), 0);
1184
1185 /* Process '-ix' and '-iex' options early. */
1187
1188 /* Now perform all the actions indicated by the arguments. */
1189 if (cdarg != NULL)
1190 {
1191 ret = catch_command_errors (cd_command, cdarg, 0);
1192 }
1193
1194 for (i = 0; i < dirarg.size (); i++)
1195 ret = catch_command_errors (directory_switch, dirarg[i], 0);
1196
1197 /* Skip auto-loading section-specified scripts until we've sourced
1198 local_gdbinit (which is often used to augment the source search
1199 path). */
1200 save_auto_load = global_auto_load;
1201 global_auto_load = 0;
1202
1203 if (execarg != NULL
1204 && symarg != NULL
1205 && strcmp (execarg, symarg) == 0)
1206 {
1207 /* The exec file and the symbol-file are the same. If we can't
1208 open it, better only print one error message.
1209 catch_command_errors returns non-zero on success! */
1210 ret = catch_command_errors (exec_file_attach, execarg,
1211 !batch_flag);
1212 if (ret != 0)
1214 symarg, !batch_flag);
1215 }
1216 else
1217 {
1218 if (execarg != NULL)
1219 ret = catch_command_errors (exec_file_attach, execarg,
1220 !batch_flag);
1221 if (symarg != NULL)
1223 symarg, !batch_flag);
1224 }
1225
1226 if (corearg && pidarg)
1227 error (_("Can't attach to process and specify "
1228 "a core file at the same time."));
1229
1230 if (corearg != NULL)
1231 {
1233 !batch_flag);
1234 }
1235 else if (pidarg != NULL)
1236 {
1238 }
1239 else if (pid_or_core_arg)
1240 {
1241 /* The user specified 'gdb program pid' or gdb program core'.
1242 If pid_or_core_arg's first character is a digit, try attach
1243 first and then corefile. Otherwise try just corefile. */
1244
1245 if (isdigit (pid_or_core_arg[0]))
1246 {
1247 ret = catch_command_errors (attach_command, pid_or_core_arg,
1248 !batch_flag);
1249 if (ret == 0)
1251 pid_or_core_arg,
1252 !batch_flag);
1253 }
1254 else
1255 {
1256 /* Can't be a pid, better be a corefile. */
1258 pid_or_core_arg,
1259 !batch_flag);
1260 }
1261 }
1262
1263 if (ttyarg != NULL)
1264 current_inferior ()->set_tty (ttyarg);
1265
1266 /* Error messages should no longer be distinguished with extra output. */
1267 warning_pre_print = _("warning: ");
1268
1269 /* Read the .gdbinit file in the current directory, *if* it isn't
1270 the same as the $HOME/.gdbinit file (it should exist, also). */
1271 if (!local_gdbinit.empty ())
1272 {
1274 = gdb_realpath (local_gdbinit.c_str ()).release ();
1275
1277 {
1278 auto_load_debug_printf ("Loading .gdbinit file \"%s\".",
1279 local_gdbinit.c_str ());
1280
1281 if (file_is_auto_load_safe (local_gdbinit.c_str ()))
1282 {
1284
1285 ret = catch_command_errors (source_script, local_gdbinit.c_str (), 0);
1286 }
1287 }
1288 }
1289
1290 /* Now that all .gdbinit's have been read and all -d options have been
1291 processed, we can read any scripts mentioned in SYMARG.
1292 We wait until now because it is common to add to the source search
1293 path in local_gdbinit. */
1294 global_auto_load = save_auto_load;
1297
1298 /* Process '-x' and '-ex' options. */
1299 execute_cmdargs (&cmdarg_vec, CMDARG_FILE, CMDARG_COMMAND, &ret);
1300
1301 /* Read in the old history after all the command files have been
1302 read. */
1303 init_history ();
1304
1305 if (batch_flag)
1306 {
1307 int error_status = EXIT_FAILURE;
1308 int *exit_arg = ret == 0 ? &error_status : NULL;
1309
1310 /* We have hit the end of the batch file. */
1311 quit_force (exit_arg, 0);
1312 }
1313}
1314
1315static void
1316captured_main (void *data)
1317{
1318 struct captured_main_args *context = (struct captured_main_args *) data;
1319
1320 captured_main_1 (context);
1321
1322 /* NOTE: cagney/1999-11-07: There is probably no reason for not
1323 moving this loop and the code found in captured_command_loop()
1324 into the command_loop() proper. The main thing holding back that
1325 change - SET_TOP_LEVEL() - has been eliminated. */
1326 while (1)
1327 {
1328 try
1329 {
1331 }
1332 catch (const gdb_exception &ex)
1333 {
1335 }
1336 }
1337 /* No exit -- exit is through quit_command. */
1338}
1339
1340int
1342{
1343 try
1344 {
1345 captured_main (args);
1346 }
1347 catch (const gdb_exception &ex)
1348 {
1350 }
1351
1352 /* The only way to end up here is by an error (normal exit is
1353 handled by quit_force()), hence always return an error status. */
1354 return 1;
1355}
1356
1357
1358/* Don't use *_filtered for printing help. We don't want to prompt
1359 for continue no matter how small the screen or how much we're going
1360 to print. */
1361
1362static void
1363print_gdb_help (struct ui_file *stream)
1364{
1365 std::vector<std::string> system_gdbinit;
1366 std::string home_gdbinit;
1367 std::string local_gdbinit;
1368 std::string home_gdbearlyinit;
1369
1370 get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
1371 get_earlyinit_files (&home_gdbearlyinit);
1372
1373 /* Note: The options in the list below are only approximately sorted
1374 in the alphabetical order, so as to group closely related options
1375 together. */
1376 gdb_puts (_("\
1377This is the GNU debugger. Usage:\n\n\
1378 gdb [options] [executable-file [core-file or process-id]]\n\
1379 gdb [options] --args executable-file [inferior-arguments ...]\n\n\
1380"), stream);
1381 gdb_puts (_("\
1382Selection of debuggee and its files:\n\n\
1383 --args Arguments after executable-file are passed to inferior.\n\
1384 --core=COREFILE Analyze the core dump COREFILE.\n\
1385 --exec=EXECFILE Use EXECFILE as the executable.\n\
1386 --pid=PID Attach to running process PID.\n\
1387 --directory=DIR Search for source files in DIR.\n\
1388 --se=FILE Use FILE as symbol file and executable file.\n\
1389 --symbols=SYMFILE Read symbols from SYMFILE.\n\
1390 --readnow Fully read symbol files on first access.\n\
1391 --readnever Do not read symbol files.\n\
1392 --write Set writing into executable and core files.\n\n\
1393"), stream);
1394 gdb_puts (_("\
1395Initial commands and command files:\n\n\
1396 --command=FILE, -x Execute GDB commands from FILE.\n\
1397 --init-command=FILE, -ix\n\
1398 Like -x but execute commands before loading inferior.\n\
1399 --eval-command=COMMAND, -ex\n\
1400 Execute a single GDB command.\n\
1401 May be used multiple times and in conjunction\n\
1402 with --command.\n\
1403 --init-eval-command=COMMAND, -iex\n\
1404 Like -ex but before loading inferior.\n\
1405 --nh Do not read ~/.gdbinit.\n\
1406 --nx Do not read any .gdbinit files in any directory.\n\n\
1407"), stream);
1408 gdb_puts (_("\
1409Output and user interface control:\n\n\
1410 --fullname Output information used by emacs-GDB interface.\n\
1411 --interpreter=INTERP\n\
1412 Select a specific interpreter / user interface.\n\
1413 --tty=TTY Use TTY for input/output by the program being debugged.\n\
1414 -w Use the GUI interface.\n\
1415 --nw Do not use the GUI interface.\n\
1416"), stream);
1417#if defined(TUI)
1418 gdb_puts (_("\
1419 --tui Use a terminal user interface.\n\
1420"), stream);
1421#endif
1422 gdb_puts (_("\
1423 -q, --quiet, --silent\n\
1424 Do not print version number on startup.\n\n\
1425"), stream);
1426 gdb_puts (_("\
1427Operating modes:\n\n\
1428 --batch Exit after processing options.\n\
1429 --batch-silent Like --batch, but suppress all gdb stdout output.\n\
1430 --return-child-result\n\
1431 GDB exit code will be the child's exit code.\n\
1432 --configuration Print details about GDB configuration and then exit.\n\
1433 --help Print this message and then exit.\n\
1434 --version Print version information and then exit.\n\n\
1435Remote debugging options:\n\n\
1436 -b BAUDRATE Set serial port baud rate used for remote debugging.\n\
1437 -l TIMEOUT Set timeout in seconds for remote debugging.\n\n\
1438Other options:\n\n\
1439 --cd=DIR Change current directory to DIR.\n\
1440 --data-directory=DIR, -D\n\
1441 Set GDB's data-directory to DIR.\n\
1442"), stream);
1443 gdb_puts (_("\n\
1444At startup, GDB reads the following early init files and executes their\n\
1445commands:\n\
1446"), stream);
1447 if (!home_gdbearlyinit.empty ())
1448 gdb_printf (stream, _("\
1449 * user-specific early init file: %s\n\
1450"), home_gdbearlyinit.c_str ());
1451 if (home_gdbearlyinit.empty ())
1452 gdb_printf (stream, _("\
1453 None found.\n"));
1454 gdb_puts (_("\n\
1455At startup, GDB reads the following init files and executes their commands:\n\
1456"), stream);
1457 if (!system_gdbinit.empty ())
1458 {
1459 std::string output;
1460 for (size_t idx = 0; idx < system_gdbinit.size (); ++idx)
1461 {
1462 output += system_gdbinit[idx];
1463 if (idx < system_gdbinit.size () - 1)
1464 output += ", ";
1465 }
1466 gdb_printf (stream, _("\
1467 * system-wide init files: %s\n\
1468"), output.c_str ());
1469 }
1470 if (!home_gdbinit.empty ())
1471 gdb_printf (stream, _("\
1472 * user-specific init file: %s\n\
1473"), home_gdbinit.c_str ());
1474 if (!local_gdbinit.empty ())
1475 gdb_printf (stream, _("\
1476 * local init file (see also 'set auto-load local-gdbinit'): ./%s\n\
1477"), local_gdbinit.c_str ());
1478 if (system_gdbinit.empty () && home_gdbinit.empty ()
1479 && local_gdbinit.empty ())
1480 gdb_printf (stream, _("\
1481 None found.\n"));
1482 gdb_puts (_("\n\
1483For more information, type \"help\" from within GDB, or consult the\n\
1484GDB manual (available as on-line info or a printed manual).\n\
1485"), stream);
1486 if (REPORT_BUGS_TO[0] && stream == gdb_stdout)
1487 gdb_printf (stream, _("\n\
1488Report bugs to %ps.\n\
1490 if (stream == gdb_stdout)
1491 gdb_printf (stream, _("\n\
1492You can ask GDB-related questions on the GDB users mailing list\n\
1493(gdb@sourceware.org) or on GDB's IRC channel (#gdb on Freenode).\n"));
1494}
const char *const name
Definition: aarch64-tdep.c:67
long __attribute__((__aligned__(4)))
bool file_is_auto_load_safe(const char *filename)
Definition: auto-load.c:439
void load_auto_scripts_for_objfile(struct objfile *objfile)
Definition: auto-load.c:1149
bool auto_load_local_gdbinit_loaded
Definition: auto-load.c:127
bool auto_load_local_gdbinit
Definition: auto-load.c:121
bool global_auto_load
Definition: auto-load.c:118
char * auto_load_local_gdbinit_pathname
Definition: auto-load.c:124
#define auto_load_debug_printf(fmt,...)
Definition: auto-load.h:40
void bpstat_do_actions(void)
Definition: breakpoint.c:4754
ui_file_style style() const
Definition: cli-style.c:169
std::string m_home_file
Definition: main.c:348
gdb_initfile_finder(const char *filename, const char *system_filename, bool system_filename_relocatable, const char *system_dirname, bool system_dirname_relocatable, bool lookup_local_file)
Definition: main.c:241
std::string m_local_file
Definition: main.c:352
const std::string & home_file() const
Definition: main.c:332
std::vector< std::string > m_system_files
Definition: main.c:344
DISABLE_COPY_AND_ASSIGN(gdb_initfile_finder)
const std::string & local_file() const
Definition: main.c:337
const std::vector< std::string > & system_files() const
Definition: main.c:327
void set_tty(std::string terminal_name)
Definition: inferior.c:159
void cd_command(const char *dir, int from_tty)
Definition: cli-cmds.c:533
void source_script(const char *file, int from_tty)
Definition: cli-cmds.c:780
void quit_command(const char *args, int from_tty)
Definition: cli-cmds.c:475
bool cli_styling
Definition: cli-style.c:33
cli_style_option file_name_style
#define BINDIR
Definition: config.h:14
#define PYTHON_LIBDIR_RELOCATABLE
Definition: config.h:676
#define SYSTEM_GDBINIT_RELOCATABLE
Definition: config.h:731
#define GDBEARLYINIT
Definition: config.h:48
#define TARGET_SYSTEM_ROOT_RELOCATABLE
Definition: config.h:737
#define SYSTEM_GDBINIT_DIR_RELOCATABLE
Definition: config.h:727
#define GDBINIT
Definition: config.h:51
#define GDB_DATADIR
Definition: config.h:54
#define REPORT_BUGS_TO
Definition: config.h:685
#define WITH_PYTHON_LIBDIR
Definition: config.h:780
#define SYSTEM_GDBINIT
Definition: config.h:720
#define GDB_DATADIR_RELOCATABLE
Definition: config.h:58
#define TARGET_SYSTEM_ROOT
Definition: config.h:734
#define DEBUGDIR_RELOCATABLE
Definition: config.h:32
#define DEBUGDIR
Definition: config.h:28
#define PACKAGE
Definition: config.h:623
#define SYSTEM_GDBINIT_DIR
Definition: config.h:723
void core_file_command(const char *filename, int from_tty)
Definition: corelow.c:406
std::string debug_file_directory
Definition: symfile.c:1355
int annotation_level
Definition: stack.c:237
void async_enable_stdin(void)
Definition: event-top.c:571
void(* after_char_processing_hook)(void)
Definition: event-top.c:134
struct ui * main_ui
Definition: event-top.c:482
struct ui * current_ui
Definition: event-top.c:483
void exception_print(struct ui_file *file, const struct gdb_exception &e)
Definition: exceptions.c:105
bool write_files
Definition: exec.c:133
void exec_file_attach(const char *filename, int from_tty)
Definition: exec.c:365
int ext_lang_present_p(const struct extension_language_defn *extlang)
Definition: extension.c:150
void ext_lang_initialization(void)
Definition: extension.c:331
const struct extension_language_defn * get_ext_lang_of_file(const char *file)
Definition: extension.c:132
#define TARGET_SYSROOT_PREFIX
Definition: gdb_bfd.h:40
void execute_command(const char *, int)
Definition: top.c:574
void attach_command(const char *args, int from_tty)
Definition: infcmd.c:2607
void set_inferior_args_vector(int argc, char **argv)
Definition: infcmd.c:132
struct inferior * current_inferior(void)
Definition: inferior.c:54
void interp_pre_command_loop(struct interp *interp)
Definition: interps.c:317
int current_interp_named_p(const char *interp_name)
Definition: interps.c:282
struct interp * top_level_interpreter(void)
Definition: interps.c:431
void set_top_level_interpreter(const char *name)
Definition: interps.c:246
#define INTERP_CONSOLE
Definition: interps.h:177
#define INTERP_MI1
Definition: interps.h:178
#define INTERP_TUI
Definition: interps.h:183
#define INTERP_INSIGHT
Definition: interps.h:184
void set_gdb_data_directory(const char *new_datadir)
Definition: main.c:112
static void captured_command_loop() __attribute__((noinline))
Definition: main.c:458
static int handle_command_errors(const struct gdb_exception &e)
Definition: main.c:482
static void execute_cmdargs(const std::vector< struct cmdarg > *cmdarg_vec, cmdarg_kind file_type, cmdarg_kind cmd_type, int *ret)
Definition: main.c:598
int return_child_result_value
Definition: main.c:92
static void captured_main_1(struct captured_main_args *context)
Definition: main.c:614
std::string interpreter_p
Definition: main.c:60
static char * gdb_program_name
Definition: main.c:96
const char * get_gdb_program_name(void)
Definition: main.c:100
static void print_gdb_help(struct ui_file *)
Definition: main.c:1363
std::string python_libdir
Definition: main.c:75
std::string relocate_gdb_directory(const char *initial, bool relocatable)
Definition: main.c:164
static std::string relocate_path(const char *progname, const char *initial, bool relocatable)
Definition: main.c:144
int batch_silent
Definition: main.c:86
struct ui_file * gdb_stdtarg
Definition: main.c:79
struct ui_file * gdb_stdtargerr
Definition: main.c:80
static void captured_main(void *data)
Definition: main.c:1316
static void get_init_files(std::vector< std::string > *system_gdbinit, std::string *home_gdbinit, std::string *local_gdbinit)
Definition: main.c:362
static std::string relocate_file_path_maybe_in_datadir(const std::string &file, bool relocatable)
Definition: main.c:196
int return_child_result
Definition: main.c:91
struct ui_file * gdb_stdtargin
Definition: main.c:78
int gdb_main(struct captured_main_args *args)
Definition: main.c:1341
static int gdb_datadir_provided
Definition: main.c:71
static void start_event_loop()
Definition: main.c:399
static void validate_readnow_readnever()
Definition: main.c:546
static void get_earlyinit_files(std::string *home_gdbearlyinit)
Definition: main.c:384
cmdarg_kind
Definition: main.c:558
@ CMDARG_EARLYINIT_FILE
Definition: main.c:572
@ CMDARG_FILE
Definition: main.c:560
@ CMDARG_COMMAND
Definition: main.c:563
@ CMDARG_INIT_FILE
Definition: main.c:566
@ CMDARG_INIT_COMMAND
Definition: main.c:569
@ CMDARG_EARLYINIT_COMMAND
Definition: main.c:575
static void symbol_file_add_main_adapter(const char *arg, int from_tty)
Definition: main.c:533
int batch_flag
Definition: main.c:83
void() catch_command_errors_const_ftype(const char *, int)
Definition: main.c:500
static int catch_command_errors(catch_command_errors_const_ftype command, const char *arg, int from_tty, bool do_bp_actions=false)
Definition: main.c:505
std::string gdb_datadir
Definition: main.c:66
std::string gdb_sysroot
Definition: main.c:63
char * windows_get_absolute_argv0(const char *argv0)
Definition: mingw-hdep.c:34
void set_per_command_space(int new_value)
Definition: maint.c:923
void set_per_command_time(int new_value)
Definition: maint.c:914
observable command_error
struct program_space * current_program_space
Definition: progspace.c:39
int rate
Definition: ser-unix.c:242
int baud_rate
Definition: serial.c:622
void directory_switch(const char *dirname, int from_tty)
Definition: source.c:498
void add_substitute_path_rule(const char *from, const char *to)
Definition: source.c:1733
const char * interpreter_p
Definition: main.h:27
char ** argv
Definition: main.h:26
Definition: main.c:580
enum cmdarg_kind type
Definition: main.c:586
cmdarg(cmdarg_kind type_, char *string_)
Definition: main.c:581
char * string
Definition: main.c:590
objfiles_range objfiles()
Definition: progspace.h:209
Definition: gdbtypes.h:922
Definition: top.h:56
int async
Definition: top.h:101
enum prompt_state prompt_state
Definition: top.h:131
FILE * stdin_stream
Definition: top.h:108
FILE * instream
Definition: top.h:114
@ SYMFILE_VERBOSE
int readnow_symbol_files
Definition: symfile.c:90
void symbol_file_add_main(const char *args, symfile_add_flags add_flags)
Definition: symfile.c:1194
int readnever_symbol_files
Definition: symfile.c:94
int remote_timeout
Definition: top.c:194
void print_gdb_version(struct ui_file *stream, bool interactive)
Definition: top.c:1434
int inhibit_gdbinit
Definition: top.c:128
void quit_force(int *exit_arg, int from_tty)
Definition: top.c:1808
void init_history(void)
Definition: top.c:2058
void print_gdb_configuration(struct ui_file *stream)
Definition: top.c:1506
void maybe_wait_sync_command_done(int was_sync)
Definition: top.c:550
bool check_quiet_mode()
Definition: top.c:2203
void gdb_init()
Definition: top.c:2393
char * lim_at_start
@ PROMPT_BLOCKED
Definition: top.h:36
@ PROMPT_NEEDED
Definition: top.h:40
#define SWITCH_THRU_ALL_UIS()
Definition: top.h:210
static styled_string_s * styled_string(const ui_file_style &style, const char *str, styled_string_s &&tmp={})
Definition: ui-out.h:151
void perror_warning_with_name(const char *string)
Definition: utils.c:652
void print_sys_errmsg(const char *string, int errcode)
Definition: utils.c:662
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition: utils.c:1865
void gdb_flush(struct ui_file *stream)
Definition: utils.c:1477
const char * warning_pre_print
Definition: utils.c:118
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1788
#define gdb_stdin
Definition: utils.h:190
#define gdb_stderr
Definition: utils.h:193
#define gdb_stdout
Definition: utils.h:188