3 Copyright (C) 2000-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
21 #include "arch-utils.h"
22 #include "readline/readline.h"
23 #include "readline/tilde.h"
24 #include "completer.h"
25 #include "target.h" /* For baud_rate, remote_debug and remote_timeout. */
26 #include "gdbsupport/gdb_wait.h" /* For shell escape implementation. */
28 #include "gdb_regex.h" /* Used by apropos_command. */
29 #include "gdb_vfork.h"
31 #include "expression.h"
35 #include "filenames.h" /* For DOSish file names. */
39 #include "tracepoint.h"
40 #include "gdbsupport/filestuff.h"
48 #include "cli/cli-decode.h"
49 #include "cli/cli-script.h"
50 #include "cli/cli-setshow.h"
51 #include "cli/cli-cmds.h"
52 #include "cli/cli-style.h"
53 #include "cli/cli-utils.h"
55 #include "extension.h"
56 #include "gdbsupport/pathstuff.h"
59 #include "tui/tui.h" /* For tui_active et.al. */
66 /* Prototypes for local utility functions */
68 static void print_sal_location (const symtab_and_line
&sal
);
70 static void ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
71 const char *format
, ...)
72 ATTRIBUTE_PRINTF (2, 3);
74 static void filter_sals (std::vector
<symtab_and_line
> &);
78 unsigned int max_user_call_depth
;
80 /* Define all cmd_list_elements. */
82 /* Chain containing all defined commands. */
84 struct cmd_list_element
*cmdlist
;
86 /* Chain containing all defined info subcommands. */
88 struct cmd_list_element
*infolist
;
90 /* Chain containing all defined enable subcommands. */
92 struct cmd_list_element
*enablelist
;
94 /* Chain containing all defined disable subcommands. */
96 struct cmd_list_element
*disablelist
;
98 /* Chain containing all defined stop subcommands. */
100 struct cmd_list_element
*stoplist
;
102 /* Chain containing all defined delete subcommands. */
104 struct cmd_list_element
*deletelist
;
106 /* Chain containing all defined detach subcommands. */
108 struct cmd_list_element
*detachlist
;
110 /* Chain containing all defined kill subcommands. */
112 struct cmd_list_element
*killlist
;
114 /* Chain containing all defined set subcommands */
116 struct cmd_list_element
*setlist
;
118 /* Chain containing all defined unset subcommands */
120 struct cmd_list_element
*unsetlist
;
122 /* Chain containing all defined show subcommands. */
124 struct cmd_list_element
*showlist
;
126 /* Chain containing all defined \"set history\". */
128 struct cmd_list_element
*sethistlist
;
130 /* Chain containing all defined \"show history\". */
132 struct cmd_list_element
*showhistlist
;
134 /* Chain containing all defined \"unset history\". */
136 struct cmd_list_element
*unsethistlist
;
138 /* Chain containing all defined maintenance subcommands. */
140 struct cmd_list_element
*maintenancelist
;
142 /* Chain containing all defined "maintenance info" subcommands. */
144 struct cmd_list_element
*maintenanceinfolist
;
146 /* Chain containing all defined "maintenance print" subcommands. */
148 struct cmd_list_element
*maintenanceprintlist
;
150 /* Chain containing all defined "maintenance check" subcommands. */
152 struct cmd_list_element
*maintenancechecklist
;
154 struct cmd_list_element
*setprintlist
;
156 struct cmd_list_element
*showprintlist
;
158 struct cmd_list_element
*setdebuglist
;
160 struct cmd_list_element
*showdebuglist
;
162 struct cmd_list_element
*setchecklist
;
164 struct cmd_list_element
*showchecklist
;
166 /* Command tracing state. */
168 int source_verbose
= 0;
169 bool trace_commands
= false;
171 /* 'script-extension' option support. */
173 static const char script_ext_off
[] = "off";
174 static const char script_ext_soft
[] = "soft";
175 static const char script_ext_strict
[] = "strict";
177 static const char *const script_ext_enums
[] = {
184 static const char *script_ext_mode
= script_ext_soft
;
186 /* Utility used everywhere when at least one argument is needed and
190 error_no_arg (const char *why
)
192 error (_("Argument required (%s)."), why
);
195 /* The "info" command is defined as a prefix, with allow_unknown = 0.
196 Therefore, its own definition is called only for "info" with no
200 info_command (const char *arg
, int from_tty
)
202 printf_unfiltered (_("\"info\" must be followed by "
203 "the name of an info command.\n"));
204 help_list (infolist
, "info ", all_commands
, gdb_stdout
);
207 /* The "show" command with no arguments shows all the settings. */
210 show_command (const char *arg
, int from_tty
)
212 cmd_show_list (showlist
, from_tty
, "");
215 /* See cli/cli-cmds.h. */
218 with_command_1 (const char *set_cmd_prefix
,
219 cmd_list_element
*setlist
, const char *args
, int from_tty
)
222 error (_("Missing arguments."));
224 const char *delim
= strstr (args
, "--");
225 const char *nested_cmd
= nullptr;
228 error (_("Missing setting before '--' delimiter"));
230 if (delim
== nullptr || *skip_spaces (&delim
[2]) == '\0')
231 nested_cmd
= repeat_previous ();
233 cmd_list_element
*set_cmd
= lookup_cmd (&args
, setlist
, set_cmd_prefix
,
234 /*allow_unknown=*/ 0,
235 /*ignore_help_classes=*/ 1);
236 gdb_assert (set_cmd
!= nullptr);
238 if (set_cmd
->var
== nullptr)
239 error (_("Cannot use this setting with the \"with\" command"));
241 std::string temp_value
242 = (delim
== nullptr ? args
: std::string (args
, delim
- args
));
244 if (nested_cmd
== nullptr)
245 nested_cmd
= skip_spaces (delim
+ 2);
247 std::string org_value
= get_setshow_command_value_string (set_cmd
);
249 /* Tweak the setting to the new temporary value. */
250 do_set_command (temp_value
.c_str (), from_tty
, set_cmd
);
254 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
256 /* Execute the nested command. */
257 execute_command (nested_cmd
, from_tty
);
259 catch (const gdb_exception
&ex
)
261 /* Restore the setting and rethrow. If restoring the setting
262 throws, swallow the new exception and warn. There's nothing
263 else we can reasonably do. */
266 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
268 catch (const gdb_exception
&ex2
)
270 warning (_("Couldn't restore setting: %s"), ex2
.what ());
276 /* Restore the setting. */
277 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
280 /* See cli/cli-cmds.h. */
283 with_command_completer_1 (const char *set_cmd_prefix
,
284 completion_tracker
&tracker
,
287 tracker
.set_use_custom_word_point (true);
289 const char *delim
= strstr (text
, "--");
291 /* If we're still not past the "--" delimiter, complete the "with"
292 command as if it was a "set" command. */
295 || !isspace (delim
[-1])
296 || !(isspace (delim
[2]) || delim
[2] == '\0'))
298 std::string new_text
= std::string (set_cmd_prefix
) + text
;
299 tracker
.advance_custom_word_point_by (-(int) strlen (set_cmd_prefix
));
300 complete_nested_command_line (tracker
, new_text
.c_str ());
304 /* We're past the "--" delimiter. Complete on the sub command. */
305 const char *nested_cmd
= skip_spaces (delim
+ 2);
306 tracker
.advance_custom_word_point_by (nested_cmd
- text
);
307 complete_nested_command_line (tracker
, nested_cmd
);
310 /* The "with" command. */
313 with_command (const char *args
, int from_tty
)
315 with_command_1 ("set ", setlist
, args
, from_tty
);
318 /* "with" command completer. */
321 with_command_completer (struct cmd_list_element
*ignore
,
322 completion_tracker
&tracker
,
323 const char *text
, const char * /*word*/)
325 with_command_completer_1 ("set ", tracker
, text
);
329 /* Provide documentation on command or list given by COMMAND. FROM_TTY
333 help_command (const char *command
, int from_tty
)
335 help_cmd (command
, gdb_stdout
);
339 /* Note: The "complete" command is used by Emacs to implement completion.
340 [Is that why this function writes output with *_unfiltered?] */
343 complete_command (const char *arg
, int from_tty
)
347 if (max_completions
== 0)
349 /* Only print this for non-mi frontends. An MI frontend may not
350 be able to handle this. */
351 if (!current_uiout
->is_mi_like_p ())
353 printf_unfiltered (_("max-completions is zero,"
354 " completion is disabled.\n"));
362 int quote_char
= '\0';
365 completion_result result
= complete (arg
, &word
, "e_char
);
367 if (result
.number_matches
!= 0)
369 std::string
arg_prefix (arg
, word
- arg
);
371 if (result
.number_matches
== 1)
372 printf_unfiltered ("%s%s\n", arg_prefix
.c_str (), result
.match_list
[0]);
375 result
.sort_match_list ();
377 for (size_t i
= 0; i
< result
.number_matches
; i
++)
379 printf_unfiltered ("%s%s",
381 result
.match_list
[i
+ 1]);
383 printf_unfiltered ("%c", quote_char
);
384 printf_unfiltered ("\n");
388 if (result
.number_matches
== max_completions
)
390 /* ARG_PREFIX and WORD are included in the output so that emacs
391 will include the message in the output. */
392 printf_unfiltered (_("%s%s %s\n"),
393 arg_prefix
.c_str (), word
,
394 get_max_completions_reached_message ());
400 is_complete_command (struct cmd_list_element
*c
)
402 return cmd_cfunc_eq (c
, complete_command
);
406 show_version (const char *args
, int from_tty
)
408 print_gdb_version (gdb_stdout
, true);
409 printf_filtered ("\n");
413 show_configuration (const char *args
, int from_tty
)
415 print_gdb_configuration (gdb_stdout
);
418 /* Handle the quit command. */
421 quit_command (const char *args
, int from_tty
)
425 /* An optional expression may be used to cause gdb to terminate with
426 the value of that expression. */
429 struct value
*val
= parse_and_eval (args
);
431 exit_code
= (int) value_as_long (val
);
434 if (!quit_confirm ())
435 error (_("Not confirmed."));
437 query_if_trace_running (from_tty
);
439 quit_force (args
? &exit_code
: NULL
, from_tty
);
443 pwd_command (const char *args
, int from_tty
)
446 error (_("The \"pwd\" command does not take an argument: %s"), args
);
448 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
451 error (_("Error finding name of working directory: %s"),
452 safe_strerror (errno
));
454 if (strcmp (cwd
.get (), current_directory
) != 0)
455 printf_unfiltered (_("Working directory %ps\n (canonically %ps).\n"),
456 styled_string (file_name_style
.style (),
458 styled_string (file_name_style
.style (), cwd
.get ()));
460 printf_unfiltered (_("Working directory %ps.\n"),
461 styled_string (file_name_style
.style (),
466 cd_command (const char *dir
, int from_tty
)
469 /* Found something other than leading repetitions of "/..". */
473 /* If the new directory is absolute, repeat is a no-op; if relative,
474 repeat might be useful but is more likely to be a mistake. */
477 gdb::unique_xmalloc_ptr
<char> dir_holder
478 (tilde_expand (dir
!= NULL
? dir
: "~"));
479 dir
= dir_holder
.get ();
482 perror_with_name (dir
);
484 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
485 /* There's too much mess with DOSish names like "d:", "d:.",
486 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
487 simply get the canonicalized name of the current directory. */
488 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
493 if (IS_DIR_SEPARATOR (dir
[len
- 1]))
495 /* Remove the trailing slash unless this is a root directory
496 (including a drive letter on non-Unix systems). */
497 if (!(len
== 1) /* "/" */
498 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
499 && !(len
== 3 && dir
[1] == ':') /* "d:/" */
505 dir_holder
.reset (savestring (dir
, len
));
506 if (IS_ABSOLUTE_PATH (dir_holder
.get ()))
508 xfree (current_directory
);
509 current_directory
= dir_holder
.release ();
513 if (IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1]))
514 current_directory
= concat (current_directory
, dir_holder
.get (),
517 current_directory
= concat (current_directory
, SLASH_STRING
,
518 dir_holder
.get (), (char *) NULL
);
521 /* Now simplify any occurrences of `.' and `..' in the pathname. */
524 for (p
= current_directory
; *p
;)
526 if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.'
527 && (p
[2] == 0 || IS_DIR_SEPARATOR (p
[2])))
528 memmove (p
, p
+ 2, strlen (p
+ 2) + 1);
529 else if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.' && p
[2] == '.'
530 && (p
[3] == 0 || IS_DIR_SEPARATOR (p
[3])))
534 /* Search backwards for the directory just before the "/.."
535 and obliterate it and the "/..". */
538 while (q
!= current_directory
&& !IS_DIR_SEPARATOR (q
[-1]))
541 if (q
== current_directory
)
542 /* current_directory is
543 a relative pathname ("can't happen"--leave it alone). */
547 memmove (q
- 1, p
+ 3, strlen (p
+ 3) + 1);
552 /* We are dealing with leading repetitions of "/..", for
553 example "/../..", which is the Mach super-root. */
563 forget_cached_source_info ();
566 pwd_command ((char *) 0, 1);
569 /* Show the current value of the 'script-extension' option. */
572 show_script_ext_mode (struct ui_file
*file
, int from_tty
,
573 struct cmd_list_element
*c
, const char *value
)
575 fprintf_filtered (file
,
576 _("Script filename extension recognition is \"%s\".\n"),
580 /* Try to open SCRIPT_FILE.
581 If successful, the full path name is stored in *FULL_PATHP,
582 and the stream is returned.
583 If not successful, return NULL; errno is set for the last file
586 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
587 search for it in the source search path. */
589 gdb::optional
<open_script
>
590 find_and_open_script (const char *script_file
, int search_path
)
593 openp_flags search_flags
= OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
;
594 gdb::optional
<open_script
> opened
;
596 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (script_file
));
599 search_flags
|= OPF_SEARCH_IN_PATH
;
601 /* Search for and open 'file' on the search path used for source
602 files. Put the full location in *FULL_PATHP. */
603 gdb::unique_xmalloc_ptr
<char> full_path
;
604 fd
= openp (source_path
, search_flags
,
605 file
.get (), O_RDONLY
, &full_path
);
610 FILE *result
= fdopen (fd
, FOPEN_RT
);
613 int save_errno
= errno
;
619 opened
.emplace (gdb_file_up (result
), std::move (full_path
));
624 /* Load script FILE, which has already been opened as STREAM.
625 FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
626 This is provided as FILE may have been found via the source search path.
627 An important thing to note here is that FILE may be a symlink to a file
628 with a different or non-existing suffix, and thus one cannot infer the
629 extension language from FILE_TO_OPEN. */
632 source_script_from_stream (FILE *stream
, const char *file
,
633 const char *file_to_open
)
635 if (script_ext_mode
!= script_ext_off
)
637 const struct extension_language_defn
*extlang
638 = get_ext_lang_of_file (file
);
642 if (ext_lang_present_p (extlang
))
644 script_sourcer_func
*sourcer
645 = ext_lang_script_sourcer (extlang
);
647 gdb_assert (sourcer
!= NULL
);
648 sourcer (extlang
, stream
, file_to_open
);
651 else if (script_ext_mode
== script_ext_soft
)
653 /* Assume the file is a gdb script.
654 This is handled below. */
657 throw_ext_lang_unsupported (extlang
);
661 script_from_file (stream
, file
);
664 /* Worker to perform the "source" command.
666 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
667 search for it in the source search path. */
670 source_script_with_search (const char *file
, int from_tty
, int search_path
)
673 if (file
== NULL
|| *file
== 0)
674 error (_("source command requires file name of file to source."));
676 gdb::optional
<open_script
> opened
= find_and_open_script (file
, search_path
);
679 /* The script wasn't found, or was otherwise inaccessible.
680 If the source command was invoked interactively, throw an
681 error. Otherwise (e.g. if it was invoked by a script),
682 just emit a warning, rather than cause an error. */
684 perror_with_name (file
);
687 perror_warning_with_name (file
);
692 /* The python support reopens the file, so we need to pass full_path here
693 in case the file was found on the search path. It's useful to do this
694 anyway so that error messages show the actual file used. But only do
695 this if we (may have) used search_path, as printing the full path in
696 errors for the non-search case can be more noise than signal. */
697 source_script_from_stream (opened
->stream
.get (), file
,
698 search_path
? opened
->full_path
.get () : file
);
701 /* Wrapper around source_script_with_search to export it to main.c
702 for use in loading .gdbinit scripts. */
705 source_script (const char *file
, int from_tty
)
707 source_script_with_search (file
, from_tty
, 0);
711 source_command (const char *args
, int from_tty
)
713 const char *file
= args
;
716 scoped_restore save_source_verbose
= make_scoped_restore (&source_verbose
);
718 /* -v causes the source command to run in verbose mode.
719 -s causes the file to be searched in the source search path,
720 even if the file name contains a '/'.
721 We still have to be able to handle filenames with spaces in a
722 backward compatible way, so buildargv is not appropriate. */
726 while (args
[0] != '\0')
728 /* Make sure leading white space does not break the
730 args
= skip_spaces (args
);
735 if (args
[1] == 'v' && isspace (args
[2]))
739 /* Skip passed -v. */
742 else if (args
[1] == 's' && isspace (args
[2]))
746 /* Skip passed -s. */
753 file
= skip_spaces (args
);
756 source_script_with_search (file
, from_tty
, search_path
);
761 echo_command (const char *text
, int from_tty
)
763 const char *p
= text
;
767 while ((c
= *p
++) != '\0')
771 /* \ at end of argument is used after spaces
772 so they won't be lost. */
776 c
= parse_escape (get_current_arch (), &p
);
778 printf_filtered ("%c", c
);
781 printf_filtered ("%c", c
);
784 reset_terminal_style (gdb_stdout
);
786 /* Force this output to appear now. */
788 gdb_flush (gdb_stdout
);
791 /* Sets the last launched shell command convenience variables based on
795 exit_status_set_internal_vars (int exit_status
)
797 struct internalvar
*var_code
= lookup_internalvar ("_shell_exitcode");
798 struct internalvar
*var_signal
= lookup_internalvar ("_shell_exitsignal");
800 clear_internalvar (var_code
);
801 clear_internalvar (var_signal
);
802 if (WIFEXITED (exit_status
))
803 set_internalvar_integer (var_code
, WEXITSTATUS (exit_status
));
804 else if (WIFSIGNALED (exit_status
))
805 set_internalvar_integer (var_signal
, WTERMSIG (exit_status
));
807 warning (_("unexpected shell command exit status %d"), exit_status
);
811 shell_escape (const char *arg
, int from_tty
)
813 #if defined(CANT_FORK) || \
814 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
815 /* If ARG is NULL, they want an inferior shell, but `system' just
816 reports if the shell is available when passed a NULL arg. */
817 int rc
= system (arg
? arg
: "");
820 arg
= "inferior shell";
823 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
824 safe_strerror (errno
));
826 fprintf_unfiltered (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
828 /* Make sure to return to the directory GDB thinks it is, in case
829 the shell command we just ran changed it. */
830 chdir (current_directory
);
831 exit_status_set_internal_vars (rc
);
833 #else /* Can fork. */
836 if ((pid
= vfork ()) == 0)
838 const char *p
, *user_shell
= get_shell ();
842 /* Get the name of the shell for arg0. */
843 p
= lbasename (user_shell
);
846 execl (user_shell
, p
, (char *) 0);
848 execl (user_shell
, p
, "-c", arg
, (char *) 0);
850 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
851 safe_strerror (errno
));
856 waitpid (pid
, &status
, 0);
858 error (_("Fork failed"));
859 exit_status_set_internal_vars (status
);
860 #endif /* Can fork. */
863 /* Implementation of the "shell" command. */
866 shell_command (const char *arg
, int from_tty
)
868 shell_escape (arg
, from_tty
);
872 edit_command (const char *arg
, int from_tty
)
874 struct symtab_and_line sal
;
880 /* Pull in the current default source line if necessary. */
883 set_default_source_symtab_and_line ();
884 sal
= get_current_source_symtab_and_line ();
887 /* Bare "edit" edits file with present line. */
892 error (_("No default source file yet."));
893 sal
.line
+= get_lines_to_list () / 2;
899 /* Now should only be one argument -- decode it in SAL. */
901 event_location_up location
= string_to_event_location (&arg1
,
903 std::vector
<symtab_and_line
> sals
= decode_line_1 (location
.get (),
904 DECODE_LINE_LIST_MODE
,
913 if (sals
.size () > 1)
915 ambiguous_line_spec (sals
,
916 _("Specified line is ambiguous:\n"));
923 error (_("Junk at end of line specification."));
925 /* If line was specified by address, first print exactly which
926 line, and which file. In this case, sal.symtab == 0 means
927 address is outside of all known source files, not that user
928 failed to give a filename. */
931 struct gdbarch
*gdbarch
;
934 error (_("No source file for address %s."),
935 paddress (get_current_arch (), sal
.pc
));
937 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
938 sym
= find_pc_function (sal
.pc
);
940 printf_filtered ("%s is in %s (%s:%d).\n",
941 paddress (gdbarch
, sal
.pc
),
942 SYMBOL_PRINT_NAME (sym
),
943 symtab_to_filename_for_display (sal
.symtab
),
946 printf_filtered ("%s is at %s:%d.\n",
947 paddress (gdbarch
, sal
.pc
),
948 symtab_to_filename_for_display (sal
.symtab
),
952 /* If what was given does not imply a symtab, it must be an
953 undebuggable symbol which means no source code. */
956 error (_("No line number known for %s."), arg
);
959 if ((editor
= getenv ("EDITOR")) == NULL
)
962 fn
= symtab_to_fullname (sal
.symtab
);
964 /* Quote the file name, in case it has whitespace or other special
966 p
= xstrprintf ("%s +%d \"%s\"", editor
, sal
.line
, fn
);
967 shell_escape (p
, from_tty
);
971 /* The options for the "pipe" command. */
976 char *delimiter
= nullptr;
984 static const gdb::option::option_def pipe_cmd_option_defs
[] = {
986 gdb::option::string_option_def
<pipe_cmd_opts
> {
988 [] (pipe_cmd_opts
*opts
) { return &opts
->delimiter
; },
990 N_("Indicates to use the specified delimiter string to separate\n\
991 COMMAND from SHELL_COMMAND, in alternative to |. This is useful in\n\
992 case COMMAND contains a | character."),
997 /* Create an option_def_group for the "pipe" command's options, with
1000 static inline gdb::option::option_def_group
1001 make_pipe_cmd_options_def_group (pipe_cmd_opts
*opts
)
1003 return {{pipe_cmd_option_defs
}, opts
};
1006 /* Implementation of the "pipe" command. */
1009 pipe_command (const char *arg
, int from_tty
)
1013 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1014 gdb::option::process_options
1015 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
1017 const char *delim
= "|";
1018 if (opts
.delimiter
!= nullptr)
1019 delim
= opts
.delimiter
;
1021 const char *command
= arg
;
1022 if (command
== nullptr)
1023 error (_("Missing COMMAND"));
1025 arg
= strstr (arg
, delim
);
1028 error (_("Missing delimiter before SHELL_COMMAND"));
1030 std::string
gdb_cmd (command
, arg
- command
);
1032 arg
+= strlen (delim
); /* Skip the delimiter. */
1034 if (gdb_cmd
.empty ())
1035 gdb_cmd
= repeat_previous ();
1037 const char *shell_command
= skip_spaces (arg
);
1038 if (*shell_command
== '\0')
1039 error (_("Missing SHELL_COMMAND"));
1041 FILE *to_shell_command
= popen (shell_command
, "w");
1043 if (to_shell_command
== nullptr)
1044 error (_("Error launching \"%s\""), shell_command
);
1048 stdio_file
pipe_file (to_shell_command
);
1050 execute_command_to_ui_file (&pipe_file
, gdb_cmd
.c_str (), from_tty
);
1054 pclose (to_shell_command
);
1058 int exit_status
= pclose (to_shell_command
);
1060 if (exit_status
< 0)
1061 error (_("shell command \"%s\" failed: %s"), shell_command
,
1062 safe_strerror (errno
));
1063 exit_status_set_internal_vars (exit_status
);
1066 /* Completer for the pipe command. */
1069 pipe_command_completer (struct cmd_list_element
*ignore
,
1070 completion_tracker
&tracker
,
1071 const char *text
, const char *word_ignored
)
1075 const char *org_text
= text
;
1076 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1077 if (gdb::option::complete_options
1078 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
))
1081 const char *delimiter
= "|";
1082 if (opts
.delimiter
!= nullptr)
1083 delimiter
= opts
.delimiter
;
1085 /* Check if we're past option values already. */
1086 if (text
> org_text
&& !isspace (text
[-1]))
1089 const char *delim
= strstr (text
, delimiter
);
1091 /* If we're still not past the delimiter, complete the gdb
1093 if (delim
== nullptr || delim
== text
)
1095 complete_nested_command_line (tracker
, text
);
1099 /* We're past the delimiter. What follows is a shell command, which
1100 we don't know how to complete. */
1104 list_command (const char *arg
, int from_tty
)
1111 int linenum_beg
= 0;
1114 /* Pull in the current default source line if necessary. */
1115 if (arg
== NULL
|| ((arg
[0] == '+' || arg
[0] == '-') && arg
[1] == '\0'))
1117 set_default_source_symtab_and_line ();
1118 symtab_and_line cursal
= get_current_source_symtab_and_line ();
1120 /* If this is the first "list" since we've set the current
1121 source line, center the listing around that line. */
1122 if (get_first_line_listed () == 0)
1126 first
= std::max (cursal
.line
- get_lines_to_list () / 2, 1);
1128 /* A small special case --- if listing backwards, and we
1129 should list only one line, list the preceding line,
1130 instead of the exact line we've just shown after e.g.,
1131 stopping for a breakpoint. */
1132 if (arg
!= NULL
&& arg
[0] == '-'
1133 && get_lines_to_list () == 1 && first
> 1)
1136 print_source_lines (cursal
.symtab
, source_lines_range (first
), 0);
1139 /* "l" or "l +" lists next ten lines. */
1140 else if (arg
== NULL
|| arg
[0] == '+')
1141 print_source_lines (cursal
.symtab
,
1142 source_lines_range (cursal
.line
), 0);
1144 /* "l -" lists previous ten lines, the ones before the ten just
1146 else if (arg
[0] == '-')
1148 if (get_first_line_listed () == 1)
1149 error (_("Already at the start of %s."),
1150 symtab_to_filename_for_display (cursal
.symtab
));
1151 source_lines_range
range (get_first_line_listed (),
1152 source_lines_range::BACKWARD
);
1153 print_source_lines (cursal
.symtab
, range
, 0);
1159 /* Now if there is only one argument, decode it in SAL
1161 If there are two arguments, decode them in SAL and SAL_END
1162 and clear NO_END; however, if one of the arguments is blank,
1163 set DUMMY_BEG or DUMMY_END to record that fact. */
1165 if (!have_full_symbols () && !have_partial_symbols ())
1166 error (_("No symbol table is loaded. Use the \"file\" command."));
1168 std::vector
<symtab_and_line
> sals
;
1169 symtab_and_line sal
, sal_end
;
1176 event_location_up location
= string_to_event_location (&arg1
,
1178 sals
= decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1190 /* Record whether the BEG arg is all digits. */
1192 for (p
= arg
; p
!= arg1
&& *p
>= '0' && *p
<= '9'; p
++);
1193 linenum_beg
= (p
== arg1
);
1195 /* Save the range of the first argument, in case we need to let the
1196 user know it was ambiguous. */
1197 const char *beg
= arg
;
1198 size_t beg_len
= arg1
- beg
;
1200 while (*arg1
== ' ' || *arg1
== '\t')
1205 if (sals
.size () > 1)
1207 ambiguous_line_spec (sals
,
1208 _("Specified first line '%.*s' is ambiguous:\n"),
1209 (int) beg_len
, beg
);
1213 while (*arg1
== ' ' || *arg1
== '\t')
1219 /* Save the last argument, in case we need to let the user
1220 know it was ambiguous. */
1221 const char *end_arg
= arg1
;
1223 event_location_up location
1224 = string_to_event_location (&arg1
, current_language
);
1226 std::vector
<symtab_and_line
> sals_end
1228 ? decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1230 : decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1231 NULL
, sal
.symtab
, sal
.line
));
1233 filter_sals (sals_end
);
1234 if (sals_end
.empty ())
1236 if (sals_end
.size () > 1)
1238 ambiguous_line_spec (sals_end
,
1239 _("Specified last line '%s' is ambiguous:\n"),
1243 sal_end
= sals_end
[0];
1248 error (_("Junk at end of line specification."));
1250 if (!no_end
&& !dummy_beg
&& !dummy_end
1251 && sal
.symtab
!= sal_end
.symtab
)
1252 error (_("Specified first and last lines are in different files."));
1253 if (dummy_beg
&& dummy_end
)
1254 error (_("Two empty args do not say what lines to list."));
1256 /* If line was specified by address,
1257 first print exactly which line, and which file.
1259 In this case, sal.symtab == 0 means address is outside of all
1260 known source files, not that user failed to give a filename. */
1263 struct gdbarch
*gdbarch
;
1265 if (sal
.symtab
== 0)
1266 error (_("No source file for address %s."),
1267 paddress (get_current_arch (), sal
.pc
));
1269 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
1270 sym
= find_pc_function (sal
.pc
);
1272 printf_filtered ("%s is in %s (%s:%d).\n",
1273 paddress (gdbarch
, sal
.pc
),
1274 SYMBOL_PRINT_NAME (sym
),
1275 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1277 printf_filtered ("%s is at %s:%d.\n",
1278 paddress (gdbarch
, sal
.pc
),
1279 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1282 /* If line was not specified by just a line number, and it does not
1283 imply a symtab, it must be an undebuggable symbol which means no
1286 if (!linenum_beg
&& sal
.symtab
== 0)
1287 error (_("No line number known for %s."), arg
);
1289 /* If this command is repeated with RET,
1290 turn it into the no-arg variant. */
1293 set_repeat_arguments ("");
1295 if (dummy_beg
&& sal_end
.symtab
== 0)
1296 error (_("No default source file yet. Do \"help list\"."));
1299 source_lines_range
range (sal_end
.line
+ 1,
1300 source_lines_range::BACKWARD
);
1301 print_source_lines (sal_end
.symtab
, range
, 0);
1303 else if (sal
.symtab
== 0)
1304 error (_("No default source file yet. Do \"help list\"."));
1307 for (int i
= 0; i
< sals
.size (); i
++)
1310 int first_line
= sal
.line
- get_lines_to_list () / 2;
1313 if (sals
.size () > 1)
1314 print_sal_location (sal
);
1315 print_source_lines (sal
.symtab
, source_lines_range (first_line
), 0);
1319 print_source_lines (sal
.symtab
, source_lines_range (sal
.line
), 0);
1321 print_source_lines (sal
.symtab
,
1322 source_lines_range (sal
.line
, (sal_end
.line
+ 1)),
1326 /* Subroutine of disassemble_command to simplify it.
1327 Perform the disassembly.
1328 NAME is the name of the function if known, or NULL.
1329 [LOW,HIGH) are the range of addresses to disassemble.
1330 BLOCK is the block to disassemble; it needs to be provided
1331 when non-contiguous blocks are disassembled; otherwise
1333 MIXED is non-zero to print source with the assembler. */
1336 print_disassembly (struct gdbarch
*gdbarch
, const char *name
,
1337 CORE_ADDR low
, CORE_ADDR high
,
1338 const struct block
*block
,
1339 gdb_disassembly_flags flags
)
1342 if (!tui_is_window_visible (DISASSEM_WIN
))
1345 printf_filtered ("Dump of assembler code ");
1347 printf_filtered ("for function %s:\n", name
);
1348 if (block
== nullptr || BLOCK_CONTIGUOUS_P (block
))
1351 printf_filtered ("from %s to %s:\n",
1352 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
1354 /* Dump the specified range. */
1355 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1, low
, high
);
1359 for (int i
= 0; i
< BLOCK_NRANGES (block
); i
++)
1361 CORE_ADDR range_low
= BLOCK_RANGE_START (block
, i
);
1362 CORE_ADDR range_high
= BLOCK_RANGE_END (block
, i
);
1363 printf_filtered (_("Address range %s to %s:\n"),
1364 paddress (gdbarch
, range_low
),
1365 paddress (gdbarch
, range_high
));
1366 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1,
1367 range_low
, range_high
);
1370 printf_filtered ("End of assembler dump.\n");
1375 tui_show_assembly (gdbarch
, low
);
1380 /* Subroutine of disassemble_command to simplify it.
1381 Print a disassembly of the current function according to FLAGS. */
1384 disassemble_current_function (gdb_disassembly_flags flags
)
1386 struct frame_info
*frame
;
1387 struct gdbarch
*gdbarch
;
1388 CORE_ADDR low
, high
, pc
;
1390 const struct block
*block
;
1392 frame
= get_selected_frame (_("No frame selected."));
1393 gdbarch
= get_frame_arch (frame
);
1394 pc
= get_frame_address_in_block (frame
);
1395 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1396 error (_("No function contains program counter for selected frame."));
1398 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1401 /* FIXME: cagney/2004-02-07: This should be an observer. */
1402 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1404 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1406 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1409 /* Dump a specified section of assembly code.
1413 - dump the assembly code for the function of the current pc
1414 disassemble [/mrs] addr
1415 - dump the assembly code for the function at ADDR
1416 disassemble [/mrs] low,high
1417 disassemble [/mrs] low,+length
1418 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1420 A /m modifier will include source code with the assembly in a
1421 "source centric" view. This view lists only the file of the first insn,
1422 even if other source files are involved (e.g., inlined functions), and
1423 the output is in source order, even with optimized code. This view is
1424 considered deprecated as it hasn't been useful in practice.
1426 A /r modifier will include raw instructions in hex with the assembly.
1428 A /s modifier will include source code with the assembly, like /m, with
1429 two important differences:
1430 1) The output is still in pc address order.
1431 2) File names and contents for all relevant source files are displayed. */
1434 disassemble_command (const char *arg
, int from_tty
)
1436 struct gdbarch
*gdbarch
= get_current_arch ();
1437 CORE_ADDR low
, high
;
1440 gdb_disassembly_flags flags
;
1442 const struct block
*block
= nullptr;
1453 error (_("Missing modifier."));
1455 while (*p
&& ! isspace (*p
))
1460 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1463 flags
|= DISASSEMBLY_RAW_INSN
;
1466 flags
|= DISASSEMBLY_SOURCE
;
1469 error (_("Invalid disassembly modifier."));
1473 p
= skip_spaces (p
);
1476 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1477 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1478 error (_("Cannot specify both /m and /s."));
1482 flags
|= DISASSEMBLY_OMIT_FNAME
;
1483 disassemble_current_function (flags
);
1487 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1493 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1494 error (_("No function contains specified address."));
1496 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1499 /* FIXME: cagney/2004-02-07: This should be an observer. */
1500 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1502 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1503 flags
|= DISASSEMBLY_OMIT_FNAME
;
1507 /* Two arguments. */
1510 p
= skip_spaces (p
);
1516 high
= parse_and_eval_address (p
);
1521 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1525 make_command (const char *arg
, int from_tty
)
1528 shell_escape ("make", from_tty
);
1531 std::string cmd
= std::string ("make ") + arg
;
1533 shell_escape (cmd
.c_str (), from_tty
);
1538 show_user (const char *args
, int from_tty
)
1540 struct cmd_list_element
*c
;
1544 const char *comname
= args
;
1546 c
= lookup_cmd (&comname
, cmdlist
, "", 0, 1);
1547 if (!cli_user_command_p (c
))
1548 error (_("Not a user command."));
1549 show_user_1 (c
, "", args
, gdb_stdout
);
1553 for (c
= cmdlist
; c
; c
= c
->next
)
1555 if (cli_user_command_p (c
) || c
->prefixlist
!= NULL
)
1556 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1561 /* Search through names of commands and documentations for a certain
1562 regular expression. */
1565 apropos_command (const char *arg
, int from_tty
)
1567 bool verbose
= arg
&& check_for_argument (&arg
, "-v", 2);
1569 if (arg
== NULL
|| *arg
== '\0')
1570 error (_("REGEXP string is empty"));
1572 compiled_regex
pattern (arg
, REG_ICASE
,
1573 _("Error in regular expression"));
1575 apropos_cmd (gdb_stdout
, cmdlist
, verbose
, pattern
, "");
1578 /* Subroutine of alias_command to simplify it.
1579 Return the first N elements of ARGV flattened back to a string
1580 with a space separating each element.
1581 ARGV may not be NULL.
1582 This does not take care of quoting elements in case they contain spaces
1586 argv_to_string (char **argv
, int n
)
1591 gdb_assert (argv
!= NULL
);
1592 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1594 for (i
= 0; i
< n
; ++i
)
1604 /* Subroutine of alias_command to simplify it.
1605 Return true if COMMAND exists, unambiguously. Otherwise false. */
1608 valid_command_p (const char *command
)
1610 struct cmd_list_element
*c
;
1612 c
= lookup_cmd_1 (& command
, cmdlist
, NULL
, 1);
1614 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1617 /* This is the slightly tricky part.
1618 lookup_cmd_1 will return a pointer to the last part of COMMAND
1619 to match, leaving COMMAND pointing at the remainder. */
1620 while (*command
== ' ' || *command
== '\t')
1622 return *command
== '\0';
1625 /* Called when "alias" was incorrectly used. */
1628 alias_usage_error (void)
1630 error (_("Usage: alias [-a] [--] ALIAS = COMMAND"));
1633 /* Make an alias of an existing command. */
1636 alias_command (const char *args
, int from_tty
)
1638 int i
, alias_argc
, command_argc
;
1639 int abbrev_flag
= 0;
1641 const char *alias
, *command
;
1643 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1644 alias_usage_error ();
1646 equals
= strchr (args
, '=');
1647 std::string
args2 (args
, equals
- args
);
1649 gdb_argv
built_alias_argv (args2
.c_str ());
1650 gdb_argv
command_argv (equals
+ 1);
1652 char **alias_argv
= built_alias_argv
.get ();
1653 while (alias_argv
[0] != NULL
)
1655 if (strcmp (alias_argv
[0], "-a") == 0)
1660 else if (strcmp (alias_argv
[0], "--") == 0)
1669 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1670 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1671 alias_usage_error ();
1673 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1675 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1678 error (_("Invalid command name: %s"), alias_argv
[i
]);
1680 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1684 alias_argc
= countargv (alias_argv
);
1685 command_argc
= command_argv
.count ();
1687 /* COMMAND must exist.
1688 Reconstruct the command to remove any extraneous spaces,
1689 for better error messages. */
1690 std::string
command_string (argv_to_string (command_argv
.get (),
1692 command
= command_string
.c_str ();
1693 if (! valid_command_p (command
))
1694 error (_("Invalid command to alias to: %s"), command
);
1696 /* ALIAS must not exist. */
1697 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1698 alias
= alias_string
.c_str ();
1699 if (valid_command_p (alias
))
1700 error (_("Alias already exists: %s"), alias
);
1702 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1703 Example: alias spe = set print elements
1705 Otherwise ALIAS and COMMAND must have the same number of words,
1706 and every word except the last must identify the same prefix command;
1707 and the last word of ALIAS is made an alias of the last word of COMMAND.
1708 Example: alias set print elms = set pr elem
1709 Note that unambiguous abbreviations are allowed. */
1711 if (alias_argc
== 1)
1713 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1714 add_com_alias (xstrdup (alias_argv
[0]), command
, class_alias
,
1719 const char *alias_prefix
, *command_prefix
;
1720 struct cmd_list_element
*c_alias
, *c_command
;
1722 if (alias_argc
!= command_argc
)
1723 error (_("Mismatched command length between ALIAS and COMMAND."));
1725 /* Create copies of ALIAS and COMMAND without the last word,
1726 and use that to verify the leading elements give the same
1728 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1730 std::string
command_prefix_string (argv_to_string (command_argv
.get (),
1732 alias_prefix
= alias_prefix_string
.c_str ();
1733 command_prefix
= command_prefix_string
.c_str ();
1735 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, 1);
1736 /* We've already tried to look up COMMAND. */
1737 gdb_assert (c_command
!= NULL
1738 && c_command
!= (struct cmd_list_element
*) -1);
1739 gdb_assert (c_command
->prefixlist
!= NULL
);
1740 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, 1);
1741 if (c_alias
!= c_command
)
1742 error (_("ALIAS and COMMAND prefixes do not match."));
1744 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1745 add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1746 command_argv
[command_argc
- 1],
1747 class_alias
, abbrev_flag
, c_command
->prefixlist
);
1751 /* Print the file / line number / symbol name of the location
1752 specified by SAL. */
1755 print_sal_location (const symtab_and_line
&sal
)
1757 scoped_restore_current_program_space restore_pspace
;
1758 set_current_program_space (sal
.pspace
);
1760 const char *sym_name
= NULL
;
1761 if (sal
.symbol
!= NULL
)
1762 sym_name
= SYMBOL_PRINT_NAME (sal
.symbol
);
1763 printf_filtered (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
1764 symtab_to_filename_for_display (sal
.symtab
),
1765 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
1768 /* Print a list of files and line numbers which a user may choose from
1769 in order to list a function which was specified ambiguously (as
1770 with `list classname::overloadedfuncname', for example). The SALS
1771 array provides the filenames and line numbers. FORMAT is a
1772 printf-style format string used to tell the user what was
1776 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
1777 const char *format
, ...)
1780 va_start (ap
, format
);
1781 vprintf_filtered (format
, ap
);
1784 for (const auto &sal
: sals
)
1785 print_sal_location (sal
);
1788 /* Comparison function for filter_sals. Returns a qsort-style
1792 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1794 const char *dira
= SYMTAB_DIRNAME (sala
.symtab
);
1795 const char *dirb
= SYMTAB_DIRNAME (salb
.symtab
);
1803 else if (dirb
== NULL
)
1810 r
= filename_cmp (dira
, dirb
);
1815 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
1819 if (sala
.line
< salb
.line
)
1821 return sala
.line
== salb
.line
? 0 : 1;
1824 /* Remove any SALs that do not match the current program space, or
1825 which appear to be "file:line" duplicates. */
1828 filter_sals (std::vector
<symtab_and_line
> &sals
)
1830 /* Remove SALs that do not match. */
1831 auto from
= std::remove_if (sals
.begin (), sals
.end (),
1832 [&] (const symtab_and_line
&sal
)
1833 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
1836 std::sort (sals
.begin (), from
,
1837 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1838 { return cmp_symtabs (sala
, salb
) < 0; });
1840 from
= std::unique (sals
.begin (), from
,
1841 [&] (const symtab_and_line
&sala
,
1842 const symtab_and_line
&salb
)
1843 { return cmp_symtabs (sala
, salb
) == 0; });
1845 sals
.erase (from
, sals
.end ());
1849 set_debug (const char *arg
, int from_tty
)
1851 printf_unfiltered (_("\"set debug\" must be followed by "
1852 "the name of a debug subcommand.\n"));
1853 help_list (setdebuglist
, "set debug ", all_commands
, gdb_stdout
);
1857 show_debug (const char *args
, int from_tty
)
1859 cmd_show_list (showdebuglist
, from_tty
, "");
1863 init_cmd_lists (void)
1865 max_user_call_depth
= 1024;
1869 show_info_verbose (struct ui_file
*file
, int from_tty
,
1870 struct cmd_list_element
*c
,
1874 fprintf_filtered (file
,
1875 _("Verbose printing of informational messages is %s.\n"),
1878 fprintf_filtered (file
, _("Verbosity is %s.\n"), value
);
1882 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
1883 struct cmd_list_element
*c
, const char *value
)
1885 fprintf_filtered (file
, _("History expansion on command input is %s.\n"),
1890 show_remote_debug (struct ui_file
*file
, int from_tty
,
1891 struct cmd_list_element
*c
, const char *value
)
1893 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
1898 show_remote_timeout (struct ui_file
*file
, int from_tty
,
1899 struct cmd_list_element
*c
, const char *value
)
1901 fprintf_filtered (file
,
1902 _("Timeout limit to wait for target to respond is %s.\n"),
1907 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
1908 struct cmd_list_element
*c
, const char *value
)
1910 fprintf_filtered (file
,
1911 _("The max call depth for user-defined commands is %s.\n"),
1915 /* Returns the cmd_list_element in SHOWLIST corresponding to the first
1916 argument of ARGV, which must contain one single value.
1917 Throws an error if no value provided, or value not correct.
1918 FNNAME is used in the error message. */
1920 static cmd_list_element
*
1921 setting_cmd (const char *fnname
, struct cmd_list_element
*showlist
,
1922 int argc
, struct value
**argv
)
1925 error (_("You must provide an argument to %s"), fnname
);
1927 error (_("You can only provide one argument to %s"), fnname
);
1929 struct type
*type0
= check_typedef (value_type (argv
[0]));
1931 if (TYPE_CODE (type0
) != TYPE_CODE_ARRAY
1932 && TYPE_CODE (type0
) != TYPE_CODE_STRING
)
1933 error (_("First argument of %s must be a string."), fnname
);
1935 const char *a0
= (const char *) value_contents (argv
[0]);
1936 cmd_list_element
*cmd
= lookup_cmd (&a0
, showlist
, "", -1, 0);
1938 if (cmd
== nullptr || cmd_type (cmd
) != show_cmd
)
1939 error (_("First argument of %s must be a "
1940 "valid setting of the 'show' command."), fnname
);
1945 /* Builds a value from the show CMD. */
1947 static struct value
*
1948 value_from_setting (const cmd_list_element
*cmd
, struct gdbarch
*gdbarch
)
1950 switch (cmd
->var_type
)
1953 if (*(int *) cmd
->var
== INT_MAX
)
1954 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1957 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1960 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1963 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1964 *(bool *) cmd
->var
? 1 : 0);
1965 case var_zuinteger_unlimited
:
1966 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1968 case var_auto_boolean
:
1972 switch (*(enum auto_boolean
*) cmd
->var
)
1974 case AUTO_BOOLEAN_TRUE
:
1977 case AUTO_BOOLEAN_FALSE
:
1980 case AUTO_BOOLEAN_AUTO
:
1984 gdb_assert_not_reached ("invalid var_auto_boolean");
1986 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1990 if (*(unsigned int *) cmd
->var
== UINT_MAX
)
1991 return value_from_ulongest
1992 (builtin_type (gdbarch
)->builtin_unsigned_int
, 0);
1994 return value_from_ulongest
1995 (builtin_type (gdbarch
)->builtin_unsigned_int
,
1996 *(unsigned int *) cmd
->var
);
1998 return value_from_ulongest (builtin_type (gdbarch
)->builtin_unsigned_int
,
1999 *(unsigned int *) cmd
->var
);
2001 case var_string_noescape
:
2002 case var_optional_filename
:
2005 if (*(char **) cmd
->var
)
2006 return value_cstring (*(char **) cmd
->var
, strlen (*(char **) cmd
->var
),
2007 builtin_type (gdbarch
)->builtin_char
);
2009 return value_cstring ("", 1,
2010 builtin_type (gdbarch
)->builtin_char
);
2012 gdb_assert_not_reached ("bad var_type");
2016 /* Implementation of the convenience function $_gdb_setting. */
2018 static struct value
*
2019 gdb_setting_internal_fn (struct gdbarch
*gdbarch
,
2020 const struct language_defn
*language
,
2021 void *cookie
, int argc
, struct value
**argv
)
2023 return value_from_setting (setting_cmd ("$_gdb_setting", showlist
,
2028 /* Implementation of the convenience function $_gdb_maint_setting. */
2030 static struct value
*
2031 gdb_maint_setting_internal_fn (struct gdbarch
*gdbarch
,
2032 const struct language_defn
*language
,
2033 void *cookie
, int argc
, struct value
**argv
)
2035 return value_from_setting (setting_cmd ("$_gdb_maint_setting",
2036 maintenance_show_cmdlist
,
2041 /* Builds a string value from the show CMD. */
2043 static struct value
*
2044 str_value_from_setting (const cmd_list_element
*cmd
, struct gdbarch
*gdbarch
)
2046 switch (cmd
->var_type
)
2051 case var_zuinteger_unlimited
:
2052 case var_auto_boolean
:
2056 std::string cmd_val
= get_setshow_command_value_string (cmd
);
2058 return value_cstring (cmd_val
.c_str (), cmd_val
.size (),
2059 builtin_type (gdbarch
)->builtin_char
);
2063 case var_string_noescape
:
2064 case var_optional_filename
:
2067 /* For these cases, we do not use get_setshow_command_value_string,
2068 as this function handle some characters specially, e.g. by
2069 escaping quotes. So, we directly use the cmd->var string value,
2070 similarly to the value_from_setting code for these cases. */
2071 if (*(char **) cmd
->var
)
2072 return value_cstring (*(char **) cmd
->var
, strlen (*(char **) cmd
->var
),
2073 builtin_type (gdbarch
)->builtin_char
);
2075 return value_cstring ("", 1,
2076 builtin_type (gdbarch
)->builtin_char
);
2079 gdb_assert_not_reached ("bad var_type");
2083 /* Implementation of the convenience function $_gdb_setting_str. */
2085 static struct value
*
2086 gdb_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2087 const struct language_defn
*language
,
2088 void *cookie
, int argc
, struct value
**argv
)
2090 return str_value_from_setting (setting_cmd ("$_gdb_setting_str",
2091 showlist
, argc
, argv
),
2096 /* Implementation of the convenience function $_gdb_maint_setting_str. */
2098 static struct value
*
2099 gdb_maint_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2100 const struct language_defn
*language
,
2101 void *cookie
, int argc
, struct value
**argv
)
2103 return str_value_from_setting (setting_cmd ("$_gdb_maint_setting_str",
2104 maintenance_show_cmdlist
,
2110 _initialize_cli_cmds (void)
2112 struct cmd_list_element
*c
;
2114 /* Define the classes of commands.
2115 They will appear in the help list in alphabetical order. */
2117 add_cmd ("internals", class_maintenance
, _("\
2118 Maintenance commands.\n\
2119 Some gdb commands are provided just for use by gdb maintainers.\n\
2120 These commands are subject to frequent change, and may not be as\n\
2121 well documented as user commands."),
2123 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
2124 add_cmd ("aliases", class_alias
,
2125 _("Aliases of other commands."), &cmdlist
);
2126 add_cmd ("user-defined", class_user
, _("\
2127 User-defined commands.\n\
2128 The commands in this class are those defined by the user.\n\
2129 Use the \"define\" command to define a command."), &cmdlist
);
2130 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
2132 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
2133 add_cmd ("files", class_files
, _("Specifying and examining files."),
2135 add_cmd ("breakpoints", class_breakpoint
,
2136 _("Making program stop at certain points."), &cmdlist
);
2137 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
2138 add_cmd ("stack", class_stack
, _("\
2139 Examining the stack.\n\
2140 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
2141 counting from zero for the innermost (currently executing) frame.\n\n\
2142 At any time gdb identifies one frame as the \"selected\" frame.\n\
2143 Variable lookups are done with respect to the selected frame.\n\
2144 When the program being debugged stops, gdb selects the innermost frame.\n\
2145 The commands below can be used to select other frames by number or address."),
2147 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
2149 /* Define general commands. */
2151 add_com ("pwd", class_files
, pwd_command
, _("\
2152 Print working directory.\n\
2153 This is used for your program as well."));
2155 c
= add_cmd ("cd", class_files
, cd_command
, _("\
2156 Set working directory to DIR for debugger.\n\
2157 The debugger's current working directory specifies where scripts and other\n\
2158 files that can be loaded by GDB are located.\n\
2159 In order to change the inferior's current working directory, the recommended\n\
2160 way is to use the \"set cwd\" command."), &cmdlist
);
2161 set_cmd_completer (c
, filename_completer
);
2163 add_com ("echo", class_support
, echo_command
, _("\
2164 Print a constant string. Give string as argument.\n\
2165 C escape sequences may be used in the argument.\n\
2166 No newline is added at the end of the argument;\n\
2167 use \"\\n\" if you want a newline to be printed.\n\
2168 Since leading and trailing whitespace are ignored in command arguments,\n\
2169 if you want to print some you must use \"\\\" before leading whitespace\n\
2170 to be printed or after trailing whitespace."));
2172 add_setshow_enum_cmd ("script-extension", class_support
,
2173 script_ext_enums
, &script_ext_mode
, _("\
2174 Set mode for script filename extension recognition."), _("\
2175 Show mode for script filename extension recognition."), _("\
2176 off == no filename extension recognition (all sourced files are GDB scripts)\n\
2177 soft == evaluate script according to filename extension, fallback to GDB script"
2179 strict == evaluate script according to filename extension, error if not supported"
2182 show_script_ext_mode
,
2183 &setlist
, &showlist
);
2185 add_com ("quit", class_support
, quit_command
, _("\
2187 Usage: quit [EXPR]\n\
2188 The optional expression EXPR, if present, is evaluated and the result\n\
2189 used as GDB's exit code. The default is zero."));
2190 c
= add_com ("help", class_support
, help_command
,
2191 _("Print list of commands."));
2192 set_cmd_completer (c
, command_completer
);
2193 add_com_alias ("q", "quit", class_support
, 1);
2194 add_com_alias ("h", "help", class_support
, 1);
2196 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
2197 Set verbosity."), _("\
2198 Show verbosity."), NULL
,
2201 &setlist
, &showlist
);
2203 add_prefix_cmd ("history", class_support
, set_history
,
2204 _("Generic command for setting command history parameters."),
2205 &sethistlist
, "set history ", 0, &setlist
);
2206 add_prefix_cmd ("history", class_support
, show_history
,
2207 _("Generic command for showing command history parameters."),
2208 &showhistlist
, "show history ", 0, &showlist
);
2210 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
2211 Set history expansion on command input."), _("\
2212 Show history expansion on command input."), _("\
2213 Without an argument, history expansion is enabled."),
2215 show_history_expansion_p
,
2216 &sethistlist
, &showhistlist
);
2218 add_prefix_cmd ("info", class_info
, info_command
, _("\
2219 Generic command for showing things about the program being debugged."),
2220 &infolist
, "info ", 0, &cmdlist
);
2221 add_com_alias ("i", "info", class_info
, 1);
2222 add_com_alias ("inf", "info", class_info
, 1);
2224 add_com ("complete", class_obscure
, complete_command
,
2225 _("List the completions for the rest of the line as a command."));
2227 add_prefix_cmd ("show", class_info
, show_command
, _("\
2228 Generic command for showing things about the debugger."),
2229 &showlist
, "show ", 0, &cmdlist
);
2230 /* Another way to get at the same thing. */
2231 add_info ("set", show_command
, _("Show all GDB settings."));
2233 c
= add_com ("with", class_vars
, with_command
, _("\
2234 Temporarily set SETTING to VALUE, run COMMAND, and restore SETTING.\n\
2235 Usage: with SETTING [VALUE] [-- COMMAND]\n\
2236 Usage: w SETTING [VALUE] [-- COMMAND]\n\
2237 With no COMMAND, repeats the last executed command.\n\
2239 SETTING is any setting you can change with the \"set\" subcommands.\n\
2241 with language pascal -- print obj\n\
2242 with print elements unlimited -- print obj\n\
2244 You can change multiple settings using nested with, and use\n\
2245 abbreviations for commands and/or values. E.g.:\n\
2246 w la p -- w p el u -- p obj"));
2247 set_cmd_completer_handle_brkchars (c
, with_command_completer
);
2248 add_com_alias ("w", "with", class_vars
, 1);
2250 add_internal_function ("_gdb_setting_str", _("\
2251 $_gdb_setting_str - returns the value of a GDB setting as a string.\n\
2252 Usage: $_gdb_setting_str (setting)\n\
2254 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2255 boolean values are \"off\", \"on\".\n\
2256 Some integer settings accept an unlimited value, returned\n\
2257 as \"unlimited\"."),
2258 gdb_setting_str_internal_fn
, NULL
);
2260 add_internal_function ("_gdb_setting", _("\
2261 $_gdb_setting - returns the value of a GDB setting.\n\
2262 Usage: $_gdb_setting (setting)\n\
2263 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2264 boolean values are \"off\", \"on\".\n\
2265 Some integer settings accept an unlimited value, returned\n\
2266 as 0 or -1 depending on the setting."),
2267 gdb_setting_internal_fn
, NULL
);
2269 add_internal_function ("_gdb_maint_setting_str", _("\
2270 $_gdb_maint_setting_str - returns the value of a GDB maintenance setting as a string.\n\
2271 Usage: $_gdb_maint_setting_str (setting)\n\
2273 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2274 boolean values are \"off\", \"on\".\n\
2275 Some integer settings accept an unlimited value, returned\n\
2276 as \"unlimited\"."),
2277 gdb_maint_setting_str_internal_fn
, NULL
);
2279 add_internal_function ("_gdb_maint_setting", _("\
2280 $_gdb_maint_setting - returns the value of a GDB maintenance setting.\n\
2281 Usage: $_gdb_maint_setting (setting)\n\
2282 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2283 boolean values are \"off\", \"on\".\n\
2284 Some integer settings accept an unlimited value, returned\n\
2285 as 0 or -1 depending on the setting."),
2286 gdb_maint_setting_internal_fn
, NULL
);
2288 add_cmd ("commands", no_set_class
, show_commands
, _("\
2289 Show the history of commands you typed.\n\
2290 You can supply a command number to start with, or a `+' to start after\n\
2291 the previous command number shown."),
2294 add_cmd ("version", no_set_class
, show_version
,
2295 _("Show what version of GDB this is."), &showlist
);
2297 add_cmd ("configuration", no_set_class
, show_configuration
,
2298 _("Show how GDB was configured at build time."), &showlist
);
2300 add_setshow_zinteger_cmd ("remote", no_class
, &remote_debug
, _("\
2301 Set debugging of remote protocol."), _("\
2302 Show debugging of remote protocol."), _("\
2303 When enabled, each packet sent or received with the remote target\n\
2307 &setdebuglist
, &showdebuglist
);
2309 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
2310 &remote_timeout
, _("\
2311 Set timeout limit to wait for target to respond."), _("\
2312 Show timeout limit to wait for target to respond."), _("\
2313 This value is used to set the time limit for gdb to wait for a response\n\
2316 show_remote_timeout
,
2317 &setlist
, &showlist
);
2319 add_prefix_cmd ("debug", no_class
, set_debug
,
2320 _("Generic command for setting gdb debugging flags."),
2321 &setdebuglist
, "set debug ", 0, &setlist
);
2323 add_prefix_cmd ("debug", no_class
, show_debug
,
2324 _("Generic command for showing gdb debugging flags."),
2325 &showdebuglist
, "show debug ", 0, &showlist
);
2327 c
= add_com ("shell", class_support
, shell_command
, _("\
2328 Execute the rest of the line as a shell command.\n\
2329 With no arguments, run an inferior shell."));
2330 set_cmd_completer (c
, filename_completer
);
2332 add_com_alias ("!", "shell", class_support
, 0);
2334 c
= add_com ("edit", class_files
, edit_command
, _("\
2335 Edit specified file or function.\n\
2336 With no argument, edits file containing most recent line listed.\n\
2337 Editing targets can be specified in these ways:\n\
2338 FILE:LINENUM, to edit at that line in that file,\n\
2339 FUNCTION, to edit at the beginning of that function,\n\
2340 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2341 *ADDRESS, to edit at the line containing that address.\n\
2342 Uses EDITOR environment variable contents as editor (or ex as default)."));
2344 c
->completer
= location_completer
;
2346 c
= add_com ("pipe", class_support
, pipe_command
, _("\
2347 Send the output of a gdb command to a shell command.\n\
2348 Usage: | [COMMAND] | SHELL_COMMAND\n\
2349 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2350 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
2351 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2353 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
2355 The -d option indicates to use the string DELIM to separate COMMAND\n\
2356 from SHELL_COMMAND, in alternative to |. This is useful in\n\
2357 case COMMAND contains a | character.\n\
2359 With no COMMAND, repeat the last executed command\n\
2360 and send its output to SHELL_COMMAND."));
2361 set_cmd_completer_handle_brkchars (c
, pipe_command_completer
);
2362 add_com_alias ("|", "pipe", class_support
, 0);
2364 add_com ("list", class_files
, list_command
, _("\
2365 List specified function or line.\n\
2366 With no argument, lists ten more lines after or around previous listing.\n\
2367 \"list -\" lists the ten lines before a previous ten-line listing.\n\
2368 One argument specifies a line, and ten lines are listed around that line.\n\
2369 Two arguments with comma between specify starting and ending lines to list.\n\
2370 Lines can be specified in these ways:\n\
2371 LINENUM, to list around that line in current file,\n\
2372 FILE:LINENUM, to list around that line in that file,\n\
2373 FUNCTION, to list around beginning of that function,\n\
2374 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2375 *ADDRESS, to list around the line containing that address.\n\
2376 With two args, if one is empty, it stands for ten lines away from\n\
2379 By default, when a single location is given, display ten lines.\n\
2380 This can be changed using \"set listsize\", and the current value\n\
2381 can be shown using \"show listsize\"."));
2383 add_com_alias ("l", "list", class_files
, 1);
2386 add_com_alias ("file", "list", class_files
, 1);
2388 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
2389 Disassemble a specified section of memory.\n\
2390 Default is the function surrounding the pc of the selected frame.\n\
2392 With a /m modifier, source lines are included (if available).\n\
2393 This view is \"source centric\": the output is in source line order,\n\
2394 regardless of any optimization that is present. Only the main source file\n\
2395 is displayed, not those of, e.g., any inlined functions.\n\
2396 This modifier hasn't proved useful in practice and is deprecated\n\
2399 With a /s modifier, source lines are included (if available).\n\
2400 This differs from /m in two important respects:\n\
2401 - the output is still in pc address order, and\n\
2402 - file names and contents for all relevant source files are displayed.\n\
2404 With a /r modifier, raw instructions in hex are included.\n\
2406 With a single argument, the function surrounding that address is dumped.\n\
2407 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
2408 in the form of \"start,end\", or \"start,+length\".\n\
2410 Note that the address is interpreted as an expression, not as a location\n\
2411 like in the \"break\" command.\n\
2412 So, for example, if you want to disassemble function bar in file foo.c\n\
2413 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
2414 set_cmd_completer (c
, location_completer
);
2416 c
= add_com ("make", class_support
, make_command
, _("\
2417 Run the ``make'' program using the rest of the line as arguments."));
2418 set_cmd_completer (c
, filename_completer
);
2419 add_cmd ("user", no_class
, show_user
, _("\
2420 Show definitions of non-python/scheme user defined commands.\n\
2421 Argument is the name of the user defined command.\n\
2422 With no argument, show definitions of all user defined commands."), &showlist
);
2423 add_com ("apropos", class_support
, apropos_command
, _("\
2424 Search for commands matching a REGEXP.\n\
2425 Usage: apropos [-v] REGEXP\n\
2426 Flag -v indicates to produce a verbose output, showing full documentation\n\
2427 of the matching commands."));
2429 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
2430 &max_user_call_depth
, _("\
2431 Set the max call depth for non-python/scheme user-defined commands."), _("\
2432 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
2434 show_max_user_call_depth
,
2435 &setlist
, &showlist
);
2437 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
2438 Set tracing of GDB CLI commands."), _("\
2439 Show state of GDB CLI command tracing."), _("\
2440 When 'on', each command is displayed as it is executed."),
2443 &setlist
, &showlist
);
2445 c
= add_com ("alias", class_support
, alias_command
, _("\
2446 Define a new command that is an alias of an existing command.\n\
2447 Usage: alias [-a] [--] ALIAS = COMMAND\n\
2448 ALIAS is the name of the alias command to create.\n\
2449 COMMAND is the command being aliased to.\n\
2450 If \"-a\" is specified, the command is an abbreviation,\n\
2451 and will not appear in help command list output.\n\
2454 Make \"spe\" an alias of \"set print elements\":\n\
2455 alias spe = set print elements\n\
2456 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2457 alias -a set print elms = set print elements"));
2459 const char *source_help_text
= xstrprintf (_("\
2460 Read commands from a file named FILE.\n\
2462 Usage: source [-s] [-v] FILE\n\
2463 -s: search for the script in the source search path,\n\
2464 even if FILE contains directories.\n\
2465 -v: each command in FILE is echoed as it is executed.\n\
2467 Note that the file \"%s\" is read automatically in this way\n\
2468 when GDB is started."), GDBINIT
);
2469 c
= add_cmd ("source", class_support
, source_command
,
2470 source_help_text
, &cmdlist
);
2471 set_cmd_completer (c
, filename_completer
);