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