3 Copyright (C) 2000-2020 Free Software Foundation, Inc.
4 Copyright (C) 2019-2020 Advanced Micro Devices, Inc. All rights reserved.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "arch-utils.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
));
805 else if (WIFSIGNALED (exit_status
) && WTERMSIG (exit_status
) == -1)
807 /* The -1 condition can happen on MinGW, if we don't recognize
808 the fatal exception code encoded in the exit status; see
809 gdbsupport/gdb_wait.c. We don't want to lose information in
810 the exit status in that case. Record it as a normal exit
811 with the full exit status, including the higher 0xC0000000
813 set_internalvar_integer (var_code
, exit_status
);
816 else if (WIFSIGNALED (exit_status
))
817 set_internalvar_integer (var_signal
, WTERMSIG (exit_status
));
819 warning (_("unexpected shell command exit status %d"), exit_status
);
823 shell_escape (const char *arg
, int from_tty
)
825 #if defined(CANT_FORK) || \
826 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
827 /* If ARG is NULL, they want an inferior shell, but `system' just
828 reports if the shell is available when passed a NULL arg. */
829 int rc
= system (arg
? arg
: "");
832 arg
= "inferior shell";
835 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
836 safe_strerror (errno
));
838 fprintf_unfiltered (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
840 /* Make sure to return to the directory GDB thinks it is, in case
841 the shell command we just ran changed it. */
842 chdir (current_directory
);
843 exit_status_set_internal_vars (rc
);
845 #else /* Can fork. */
848 if ((pid
= vfork ()) == 0)
850 const char *p
, *user_shell
= get_shell ();
854 /* Get the name of the shell for arg0. */
855 p
= lbasename (user_shell
);
858 execl (user_shell
, p
, (char *) 0);
860 execl (user_shell
, p
, "-c", arg
, (char *) 0);
862 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
863 safe_strerror (errno
));
868 waitpid (pid
, &status
, 0);
870 error (_("Fork failed"));
871 exit_status_set_internal_vars (status
);
872 #endif /* Can fork. */
875 /* Implementation of the "shell" command. */
878 shell_command (const char *arg
, int from_tty
)
880 shell_escape (arg
, from_tty
);
884 edit_command (const char *arg
, int from_tty
)
886 struct symtab_and_line sal
;
892 /* Pull in the current default source line if necessary. */
895 set_default_source_symtab_and_line ();
896 sal
= get_current_source_symtab_and_line ();
899 /* Bare "edit" edits file with present line. */
904 error (_("No default source file yet."));
905 sal
.line
+= get_lines_to_list () / 2;
911 /* Now should only be one argument -- decode it in SAL. */
913 event_location_up location
= string_to_event_location (&arg1
,
915 std::vector
<symtab_and_line
> sals
= decode_line_1 (location
.get (),
916 DECODE_LINE_LIST_MODE
,
925 if (sals
.size () > 1)
927 ambiguous_line_spec (sals
,
928 _("Specified line is ambiguous:\n"));
935 error (_("Junk at end of line specification."));
937 /* If line was specified by address, first print exactly which
938 line, and which file. In this case, sal.symtab == 0 means
939 address is outside of all known source files, not that user
940 failed to give a filename. */
943 struct gdbarch
*gdbarch
;
946 error (_("No source file for address %s."),
947 paddress (get_current_arch (), sal
.pc
));
949 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
950 sym
= find_pc_function (sal
.pc
);
952 printf_filtered ("%s is in %s (%s:%d).\n",
953 paddress (gdbarch
, sal
.pc
),
955 symtab_to_filename_for_display (sal
.symtab
),
958 printf_filtered ("%s is at %s:%d.\n",
959 paddress (gdbarch
, sal
.pc
),
960 symtab_to_filename_for_display (sal
.symtab
),
964 /* If what was given does not imply a symtab, it must be an
965 undebuggable symbol which means no source code. */
968 error (_("No line number known for %s."), arg
);
971 if ((editor
= getenv ("EDITOR")) == NULL
)
974 fn
= symtab_to_fullname (sal
.symtab
);
976 /* Quote the file name, in case it has whitespace or other special
978 p
= xstrprintf ("%s +%d \"%s\"", editor
, sal
.line
, fn
);
979 shell_escape (p
, from_tty
);
983 /* The options for the "pipe" command. */
988 char *delimiter
= nullptr;
996 static const gdb::option::option_def pipe_cmd_option_defs
[] = {
998 gdb::option::string_option_def
<pipe_cmd_opts
> {
1000 [] (pipe_cmd_opts
*opts
) { return &opts
->delimiter
; },
1002 N_("Indicates to use the specified delimiter string to separate\n\
1003 COMMAND from SHELL_COMMAND, in alternative to |. This is useful in\n\
1004 case COMMAND contains a | character."),
1009 /* Create an option_def_group for the "pipe" command's options, with
1012 static inline gdb::option::option_def_group
1013 make_pipe_cmd_options_def_group (pipe_cmd_opts
*opts
)
1015 return {{pipe_cmd_option_defs
}, opts
};
1018 /* Implementation of the "pipe" command. */
1021 pipe_command (const char *arg
, int from_tty
)
1025 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1026 gdb::option::process_options
1027 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
1029 const char *delim
= "|";
1030 if (opts
.delimiter
!= nullptr)
1031 delim
= opts
.delimiter
;
1033 const char *command
= arg
;
1034 if (command
== nullptr)
1035 error (_("Missing COMMAND"));
1037 arg
= strstr (arg
, delim
);
1040 error (_("Missing delimiter before SHELL_COMMAND"));
1042 std::string
gdb_cmd (command
, arg
- command
);
1044 arg
+= strlen (delim
); /* Skip the delimiter. */
1046 if (gdb_cmd
.empty ())
1047 gdb_cmd
= repeat_previous ();
1049 const char *shell_command
= skip_spaces (arg
);
1050 if (*shell_command
== '\0')
1051 error (_("Missing SHELL_COMMAND"));
1053 FILE *to_shell_command
= popen (shell_command
, "w");
1055 if (to_shell_command
== nullptr)
1056 error (_("Error launching \"%s\""), shell_command
);
1060 stdio_file
pipe_file (to_shell_command
);
1062 execute_command_to_ui_file (&pipe_file
, gdb_cmd
.c_str (), from_tty
);
1066 pclose (to_shell_command
);
1070 int exit_status
= pclose (to_shell_command
);
1072 if (exit_status
< 0)
1073 error (_("shell command \"%s\" failed: %s"), shell_command
,
1074 safe_strerror (errno
));
1075 exit_status_set_internal_vars (exit_status
);
1078 /* Completer for the pipe command. */
1081 pipe_command_completer (struct cmd_list_element
*ignore
,
1082 completion_tracker
&tracker
,
1083 const char *text
, const char *word_ignored
)
1087 const char *org_text
= text
;
1088 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1089 if (gdb::option::complete_options
1090 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
))
1093 const char *delimiter
= "|";
1094 if (opts
.delimiter
!= nullptr)
1095 delimiter
= opts
.delimiter
;
1097 /* Check if we're past option values already. */
1098 if (text
> org_text
&& !isspace (text
[-1]))
1101 const char *delim
= strstr (text
, delimiter
);
1103 /* If we're still not past the delimiter, complete the gdb
1105 if (delim
== nullptr || delim
== text
)
1107 complete_nested_command_line (tracker
, text
);
1111 /* We're past the delimiter. What follows is a shell command, which
1112 we don't know how to complete. */
1116 list_command (const char *arg
, int from_tty
)
1123 int linenum_beg
= 0;
1126 /* Pull in the current default source line if necessary. */
1127 if (arg
== NULL
|| ((arg
[0] == '+' || arg
[0] == '-') && arg
[1] == '\0'))
1129 set_default_source_symtab_and_line ();
1130 symtab_and_line cursal
= get_current_source_symtab_and_line ();
1132 /* If this is the first "list" since we've set the current
1133 source line, center the listing around that line. */
1134 if (get_first_line_listed () == 0)
1138 first
= std::max (cursal
.line
- get_lines_to_list () / 2, 1);
1140 /* A small special case --- if listing backwards, and we
1141 should list only one line, list the preceding line,
1142 instead of the exact line we've just shown after e.g.,
1143 stopping for a breakpoint. */
1144 if (arg
!= NULL
&& arg
[0] == '-'
1145 && get_lines_to_list () == 1 && first
> 1)
1148 print_source_lines (cursal
.symtab
, source_lines_range (first
), 0);
1151 /* "l" or "l +" lists next ten lines. */
1152 else if (arg
== NULL
|| arg
[0] == '+')
1153 print_source_lines (cursal
.symtab
,
1154 source_lines_range (cursal
.line
), 0);
1156 /* "l -" lists previous ten lines, the ones before the ten just
1158 else if (arg
[0] == '-')
1160 if (get_first_line_listed () == 1)
1161 error (_("Already at the start of %s."),
1162 symtab_to_filename_for_display (cursal
.symtab
));
1163 source_lines_range
range (get_first_line_listed (),
1164 source_lines_range::BACKWARD
);
1165 print_source_lines (cursal
.symtab
, range
, 0);
1171 /* Now if there is only one argument, decode it in SAL
1173 If there are two arguments, decode them in SAL and SAL_END
1174 and clear NO_END; however, if one of the arguments is blank,
1175 set DUMMY_BEG or DUMMY_END to record that fact. */
1177 if (!have_full_symbols () && !have_partial_symbols ())
1178 error (_("No symbol table is loaded. Use the \"file\" command."));
1180 std::vector
<symtab_and_line
> sals
;
1181 symtab_and_line sal
, sal_end
;
1188 event_location_up location
= string_to_event_location (&arg1
,
1190 sals
= decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1202 /* Record whether the BEG arg is all digits. */
1204 for (p
= arg
; p
!= arg1
&& *p
>= '0' && *p
<= '9'; p
++);
1205 linenum_beg
= (p
== arg1
);
1207 /* Save the range of the first argument, in case we need to let the
1208 user know it was ambiguous. */
1209 const char *beg
= arg
;
1210 size_t beg_len
= arg1
- beg
;
1212 while (*arg1
== ' ' || *arg1
== '\t')
1217 if (sals
.size () > 1)
1219 ambiguous_line_spec (sals
,
1220 _("Specified first line '%.*s' is ambiguous:\n"),
1221 (int) beg_len
, beg
);
1225 while (*arg1
== ' ' || *arg1
== '\t')
1231 /* Save the last argument, in case we need to let the user
1232 know it was ambiguous. */
1233 const char *end_arg
= arg1
;
1235 event_location_up location
1236 = string_to_event_location (&arg1
, current_language
);
1238 std::vector
<symtab_and_line
> sals_end
1240 ? decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1242 : decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1243 NULL
, sal
.symtab
, sal
.line
));
1245 filter_sals (sals_end
);
1246 if (sals_end
.empty ())
1248 if (sals_end
.size () > 1)
1250 ambiguous_line_spec (sals_end
,
1251 _("Specified last line '%s' is ambiguous:\n"),
1255 sal_end
= sals_end
[0];
1260 error (_("Junk at end of line specification."));
1262 if (!no_end
&& !dummy_beg
&& !dummy_end
1263 && sal
.symtab
!= sal_end
.symtab
)
1264 error (_("Specified first and last lines are in different files."));
1265 if (dummy_beg
&& dummy_end
)
1266 error (_("Two empty args do not say what lines to list."));
1268 /* If line was specified by address,
1269 first print exactly which line, and which file.
1271 In this case, sal.symtab == 0 means address is outside of all
1272 known source files, not that user failed to give a filename. */
1275 struct gdbarch
*gdbarch
;
1277 if (sal
.symtab
== 0)
1278 error (_("No source file for address %s."),
1279 paddress (get_current_arch (), sal
.pc
));
1281 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
1282 sym
= find_pc_function (sal
.pc
);
1284 printf_filtered ("%s is in %s (%s:%d).\n",
1285 paddress (gdbarch
, sal
.pc
),
1287 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1289 printf_filtered ("%s is at %s:%d.\n",
1290 paddress (gdbarch
, sal
.pc
),
1291 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1294 /* If line was not specified by just a line number, and it does not
1295 imply a symtab, it must be an undebuggable symbol which means no
1298 if (!linenum_beg
&& sal
.symtab
== 0)
1299 error (_("No line number known for %s."), arg
);
1301 /* If this command is repeated with RET,
1302 turn it into the no-arg variant. */
1305 set_repeat_arguments ("");
1307 if (dummy_beg
&& sal_end
.symtab
== 0)
1308 error (_("No default source file yet. Do \"help list\"."));
1311 source_lines_range
range (sal_end
.line
+ 1,
1312 source_lines_range::BACKWARD
);
1313 print_source_lines (sal_end
.symtab
, range
, 0);
1315 else if (sal
.symtab
== 0)
1316 error (_("No default source file yet. Do \"help list\"."));
1319 for (int i
= 0; i
< sals
.size (); i
++)
1322 int first_line
= sal
.line
- get_lines_to_list () / 2;
1325 if (sals
.size () > 1)
1326 print_sal_location (sal
);
1327 print_source_lines (sal
.symtab
, source_lines_range (first_line
), 0);
1331 print_source_lines (sal
.symtab
, source_lines_range (sal
.line
), 0);
1333 print_source_lines (sal
.symtab
,
1334 source_lines_range (sal
.line
, (sal_end
.line
+ 1)),
1338 /* Subroutine of disassemble_command to simplify it.
1339 Perform the disassembly.
1340 NAME is the name of the function if known, or NULL.
1341 [LOW,HIGH) are the range of addresses to disassemble.
1342 BLOCK is the block to disassemble; it needs to be provided
1343 when non-contiguous blocks are disassembled; otherwise
1345 MIXED is non-zero to print source with the assembler. */
1348 print_disassembly (struct gdbarch
*gdbarch
, const char *name
,
1349 CORE_ADDR low
, CORE_ADDR high
,
1350 const struct block
*block
,
1351 gdb_disassembly_flags flags
)
1354 if (tui_is_window_visible (DISASSEM_WIN
))
1355 tui_show_assembly (gdbarch
, low
);
1359 printf_filtered ("Dump of assembler code ");
1361 printf_filtered ("for function %s:\n", name
);
1362 if (block
== nullptr || BLOCK_CONTIGUOUS_P (block
))
1365 printf_filtered ("from %s to %s:\n",
1366 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
1368 /* Dump the specified range. */
1369 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1, low
, high
);
1373 for (int i
= 0; i
< BLOCK_NRANGES (block
); i
++)
1375 CORE_ADDR range_low
= BLOCK_RANGE_START (block
, i
);
1376 CORE_ADDR range_high
= BLOCK_RANGE_END (block
, i
);
1377 printf_filtered (_("Address range %s to %s:\n"),
1378 paddress (gdbarch
, range_low
),
1379 paddress (gdbarch
, range_high
));
1380 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1,
1381 range_low
, range_high
);
1384 printf_filtered ("End of assembler dump.\n");
1388 /* Subroutine of disassemble_command to simplify it.
1389 Print a disassembly of the current function according to FLAGS. */
1392 disassemble_current_function (gdb_disassembly_flags flags
)
1394 struct frame_info
*frame
;
1395 struct gdbarch
*gdbarch
;
1396 CORE_ADDR low
, high
, pc
;
1398 const struct block
*block
;
1400 frame
= get_selected_frame (_("No frame selected."));
1401 gdbarch
= get_frame_arch (frame
);
1402 pc
= get_frame_address_in_block (frame
);
1403 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1404 error (_("No function contains program counter for selected frame."));
1406 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1409 /* FIXME: cagney/2004-02-07: This should be an observer. */
1410 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1412 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1414 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1417 /* Dump a specified section of assembly code.
1421 - dump the assembly code for the function of the current pc
1422 disassemble [/mrs] addr
1423 - dump the assembly code for the function at ADDR
1424 disassemble [/mrs] low,high
1425 disassemble [/mrs] low,+length
1426 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1428 A /m modifier will include source code with the assembly in a
1429 "source centric" view. This view lists only the file of the first insn,
1430 even if other source files are involved (e.g., inlined functions), and
1431 the output is in source order, even with optimized code. This view is
1432 considered deprecated as it hasn't been useful in practice.
1434 A /r modifier will include raw instructions in hex with the assembly.
1436 A /s modifier will include source code with the assembly, like /m, with
1437 two important differences:
1438 1) The output is still in pc address order.
1439 2) File names and contents for all relevant source files are displayed. */
1442 disassemble_command (const char *arg
, int from_tty
)
1444 struct gdbarch
*gdbarch
= get_current_arch ();
1445 struct obj_section
*section
;
1446 CORE_ADDR low
, high
;
1449 gdb_disassembly_flags flags
;
1451 const struct block
*block
= nullptr;
1462 error (_("Missing modifier."));
1464 while (*p
&& ! isspace (*p
))
1469 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1472 flags
|= DISASSEMBLY_RAW_INSN
;
1475 flags
|= DISASSEMBLY_SOURCE
;
1478 error (_("Invalid disassembly modifier."));
1482 p
= skip_spaces (p
);
1485 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1486 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1487 error (_("Cannot specify both /m and /s."));
1491 flags
|= DISASSEMBLY_OMIT_FNAME
;
1492 disassemble_current_function (flags
);
1496 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1498 /* ROCM: get the gdbarch from the objfile, if found */
1499 section
= find_pc_overlay (pc
);
1500 if (section
== NULL
)
1501 section
= find_pc_section (pc
);
1502 if (section
!= NULL
)
1503 gdbarch
= get_objfile_arch (section
->objfile
);
1510 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1511 error (_("No function contains specified address."));
1513 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1516 /* FIXME: cagney/2004-02-07: This should be an observer. */
1517 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1519 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1520 flags
|= DISASSEMBLY_OMIT_FNAME
;
1524 /* Two arguments. */
1527 p
= skip_spaces (p
);
1533 high
= parse_and_eval_address (p
);
1538 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1542 make_command (const char *arg
, int from_tty
)
1545 shell_escape ("make", from_tty
);
1548 std::string cmd
= std::string ("make ") + arg
;
1550 shell_escape (cmd
.c_str (), from_tty
);
1555 show_user (const char *args
, int from_tty
)
1557 struct cmd_list_element
*c
;
1561 const char *comname
= args
;
1563 c
= lookup_cmd (&comname
, cmdlist
, "", 0, 1);
1564 if (!cli_user_command_p (c
))
1565 error (_("Not a user command."));
1566 show_user_1 (c
, "", args
, gdb_stdout
);
1570 for (c
= cmdlist
; c
; c
= c
->next
)
1572 if (cli_user_command_p (c
) || c
->prefixlist
!= NULL
)
1573 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1578 /* Search through names of commands and documentations for a certain
1579 regular expression. */
1582 apropos_command (const char *arg
, int from_tty
)
1584 bool verbose
= arg
&& check_for_argument (&arg
, "-v", 2);
1586 if (arg
== NULL
|| *arg
== '\0')
1587 error (_("REGEXP string is empty"));
1589 compiled_regex
pattern (arg
, REG_ICASE
,
1590 _("Error in regular expression"));
1592 apropos_cmd (gdb_stdout
, cmdlist
, verbose
, pattern
, "");
1595 /* Subroutine of alias_command to simplify it.
1596 Return the first N elements of ARGV flattened back to a string
1597 with a space separating each element.
1598 ARGV may not be NULL.
1599 This does not take care of quoting elements in case they contain spaces
1603 argv_to_string (char **argv
, int n
)
1608 gdb_assert (argv
!= NULL
);
1609 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1611 for (i
= 0; i
< n
; ++i
)
1621 /* Subroutine of alias_command to simplify it.
1622 Return true if COMMAND exists, unambiguously. Otherwise false. */
1625 valid_command_p (const char *command
)
1627 struct cmd_list_element
*c
;
1629 c
= lookup_cmd_1 (& command
, cmdlist
, NULL
, 1);
1631 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1634 /* This is the slightly tricky part.
1635 lookup_cmd_1 will return a pointer to the last part of COMMAND
1636 to match, leaving COMMAND pointing at the remainder. */
1637 while (*command
== ' ' || *command
== '\t')
1639 return *command
== '\0';
1642 /* Called when "alias" was incorrectly used. */
1645 alias_usage_error (void)
1647 error (_("Usage: alias [-a] [--] ALIAS = COMMAND"));
1650 /* Make an alias of an existing command. */
1653 alias_command (const char *args
, int from_tty
)
1655 int i
, alias_argc
, command_argc
;
1656 int abbrev_flag
= 0;
1658 const char *alias
, *command
;
1660 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1661 alias_usage_error ();
1663 equals
= strchr (args
, '=');
1664 std::string
args2 (args
, equals
- args
);
1666 gdb_argv
built_alias_argv (args2
.c_str ());
1667 gdb_argv
command_argv (equals
+ 1);
1669 char **alias_argv
= built_alias_argv
.get ();
1670 while (alias_argv
[0] != NULL
)
1672 if (strcmp (alias_argv
[0], "-a") == 0)
1677 else if (strcmp (alias_argv
[0], "--") == 0)
1686 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1687 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1688 alias_usage_error ();
1690 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1692 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1695 error (_("Invalid command name: %s"), alias_argv
[i
]);
1697 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1701 alias_argc
= countargv (alias_argv
);
1702 command_argc
= command_argv
.count ();
1704 /* COMMAND must exist.
1705 Reconstruct the command to remove any extraneous spaces,
1706 for better error messages. */
1707 std::string
command_string (argv_to_string (command_argv
.get (),
1709 command
= command_string
.c_str ();
1710 if (! valid_command_p (command
))
1711 error (_("Invalid command to alias to: %s"), command
);
1713 /* ALIAS must not exist. */
1714 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1715 alias
= alias_string
.c_str ();
1716 if (valid_command_p (alias
))
1717 error (_("Alias already exists: %s"), alias
);
1719 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1720 Example: alias spe = set print elements
1722 Otherwise ALIAS and COMMAND must have the same number of words,
1723 and every word except the last must identify the same prefix command;
1724 and the last word of ALIAS is made an alias of the last word of COMMAND.
1725 Example: alias set print elms = set pr elem
1726 Note that unambiguous abbreviations are allowed. */
1728 if (alias_argc
== 1)
1730 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1731 add_com_alias (xstrdup (alias_argv
[0]), command
, class_alias
,
1736 const char *alias_prefix
, *command_prefix
;
1737 struct cmd_list_element
*c_alias
, *c_command
;
1739 if (alias_argc
!= command_argc
)
1740 error (_("Mismatched command length between ALIAS and COMMAND."));
1742 /* Create copies of ALIAS and COMMAND without the last word,
1743 and use that to verify the leading elements give the same
1745 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1747 std::string
command_prefix_string (argv_to_string (command_argv
.get (),
1749 alias_prefix
= alias_prefix_string
.c_str ();
1750 command_prefix
= command_prefix_string
.c_str ();
1752 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, 1);
1753 /* We've already tried to look up COMMAND. */
1754 gdb_assert (c_command
!= NULL
1755 && c_command
!= (struct cmd_list_element
*) -1);
1756 gdb_assert (c_command
->prefixlist
!= NULL
);
1757 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, 1);
1758 if (c_alias
!= c_command
)
1759 error (_("ALIAS and COMMAND prefixes do not match."));
1761 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1762 add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1763 command_argv
[command_argc
- 1],
1764 class_alias
, abbrev_flag
, c_command
->prefixlist
);
1768 /* Print the file / line number / symbol name of the location
1769 specified by SAL. */
1772 print_sal_location (const symtab_and_line
&sal
)
1774 scoped_restore_current_program_space restore_pspace
;
1775 set_current_program_space (sal
.pspace
);
1777 const char *sym_name
= NULL
;
1778 if (sal
.symbol
!= NULL
)
1779 sym_name
= sal
.symbol
->print_name ();
1780 printf_filtered (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
1781 symtab_to_filename_for_display (sal
.symtab
),
1782 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
1785 /* Print a list of files and line numbers which a user may choose from
1786 in order to list a function which was specified ambiguously (as
1787 with `list classname::overloadedfuncname', for example). The SALS
1788 array provides the filenames and line numbers. FORMAT is a
1789 printf-style format string used to tell the user what was
1793 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
1794 const char *format
, ...)
1797 va_start (ap
, format
);
1798 vprintf_filtered (format
, ap
);
1801 for (const auto &sal
: sals
)
1802 print_sal_location (sal
);
1805 /* Comparison function for filter_sals. Returns a qsort-style
1809 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1811 const char *dira
= SYMTAB_DIRNAME (sala
.symtab
);
1812 const char *dirb
= SYMTAB_DIRNAME (salb
.symtab
);
1820 else if (dirb
== NULL
)
1827 r
= filename_cmp (dira
, dirb
);
1832 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
1836 if (sala
.line
< salb
.line
)
1838 return sala
.line
== salb
.line
? 0 : 1;
1841 /* Remove any SALs that do not match the current program space, or
1842 which appear to be "file:line" duplicates. */
1845 filter_sals (std::vector
<symtab_and_line
> &sals
)
1847 /* Remove SALs that do not match. */
1848 auto from
= std::remove_if (sals
.begin (), sals
.end (),
1849 [&] (const symtab_and_line
&sal
)
1850 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
1853 std::sort (sals
.begin (), from
,
1854 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1855 { return cmp_symtabs (sala
, salb
) < 0; });
1857 from
= std::unique (sals
.begin (), from
,
1858 [&] (const symtab_and_line
&sala
,
1859 const symtab_and_line
&salb
)
1860 { return cmp_symtabs (sala
, salb
) == 0; });
1862 sals
.erase (from
, sals
.end ());
1866 set_debug (const char *arg
, int from_tty
)
1868 printf_unfiltered (_("\"set debug\" must be followed by "
1869 "the name of a debug subcommand.\n"));
1870 help_list (setdebuglist
, "set debug ", all_commands
, gdb_stdout
);
1874 show_debug (const char *args
, int from_tty
)
1876 cmd_show_list (showdebuglist
, from_tty
, "");
1880 init_cmd_lists (void)
1882 max_user_call_depth
= 1024;
1886 show_info_verbose (struct ui_file
*file
, int from_tty
,
1887 struct cmd_list_element
*c
,
1891 fprintf_filtered (file
,
1892 _("Verbose printing of informational messages is %s.\n"),
1895 fprintf_filtered (file
, _("Verbosity is %s.\n"), value
);
1899 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
1900 struct cmd_list_element
*c
, const char *value
)
1902 fprintf_filtered (file
, _("History expansion on command input is %s.\n"),
1907 show_remote_debug (struct ui_file
*file
, int from_tty
,
1908 struct cmd_list_element
*c
, const char *value
)
1910 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
1915 show_remote_timeout (struct ui_file
*file
, int from_tty
,
1916 struct cmd_list_element
*c
, const char *value
)
1918 fprintf_filtered (file
,
1919 _("Timeout limit to wait for target to respond is %s.\n"),
1924 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
1925 struct cmd_list_element
*c
, const char *value
)
1927 fprintf_filtered (file
,
1928 _("The max call depth for user-defined commands is %s.\n"),
1932 /* Returns the cmd_list_element in SHOWLIST corresponding to the first
1933 argument of ARGV, which must contain one single value.
1934 Throws an error if no value provided, or value not correct.
1935 FNNAME is used in the error message. */
1937 static cmd_list_element
*
1938 setting_cmd (const char *fnname
, struct cmd_list_element
*showlist
,
1939 int argc
, struct value
**argv
)
1942 error (_("You must provide an argument to %s"), fnname
);
1944 error (_("You can only provide one argument to %s"), fnname
);
1946 struct type
*type0
= check_typedef (value_type (argv
[0]));
1948 if (TYPE_CODE (type0
) != TYPE_CODE_ARRAY
1949 && TYPE_CODE (type0
) != TYPE_CODE_STRING
)
1950 error (_("First argument of %s must be a string."), fnname
);
1952 const char *a0
= (const char *) value_contents (argv
[0]);
1953 cmd_list_element
*cmd
= lookup_cmd (&a0
, showlist
, "", -1, 0);
1955 if (cmd
== nullptr || cmd_type (cmd
) != show_cmd
)
1956 error (_("First argument of %s must be a "
1957 "valid setting of the 'show' command."), fnname
);
1962 /* Builds a value from the show CMD. */
1964 static struct value
*
1965 value_from_setting (const cmd_list_element
*cmd
, struct gdbarch
*gdbarch
)
1967 switch (cmd
->var_type
)
1970 if (*(int *) cmd
->var
== INT_MAX
)
1971 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1974 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1977 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1980 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1981 *(bool *) cmd
->var
? 1 : 0);
1982 case var_zuinteger_unlimited
:
1983 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1985 case var_auto_boolean
:
1989 switch (*(enum auto_boolean
*) cmd
->var
)
1991 case AUTO_BOOLEAN_TRUE
:
1994 case AUTO_BOOLEAN_FALSE
:
1997 case AUTO_BOOLEAN_AUTO
:
2001 gdb_assert_not_reached ("invalid var_auto_boolean");
2003 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2007 if (*(unsigned int *) cmd
->var
== UINT_MAX
)
2008 return value_from_ulongest
2009 (builtin_type (gdbarch
)->builtin_unsigned_int
, 0);
2011 return value_from_ulongest
2012 (builtin_type (gdbarch
)->builtin_unsigned_int
,
2013 *(unsigned int *) cmd
->var
);
2015 return value_from_ulongest (builtin_type (gdbarch
)->builtin_unsigned_int
,
2016 *(unsigned int *) cmd
->var
);
2018 case var_string_noescape
:
2019 case var_optional_filename
:
2022 if (*(char **) cmd
->var
)
2023 return value_cstring (*(char **) cmd
->var
, strlen (*(char **) cmd
->var
),
2024 builtin_type (gdbarch
)->builtin_char
);
2026 return value_cstring ("", 1,
2027 builtin_type (gdbarch
)->builtin_char
);
2029 gdb_assert_not_reached ("bad var_type");
2033 /* Implementation of the convenience function $_gdb_setting. */
2035 static struct value
*
2036 gdb_setting_internal_fn (struct gdbarch
*gdbarch
,
2037 const struct language_defn
*language
,
2038 void *cookie
, int argc
, struct value
**argv
)
2040 return value_from_setting (setting_cmd ("$_gdb_setting", showlist
,
2045 /* Implementation of the convenience function $_gdb_maint_setting. */
2047 static struct value
*
2048 gdb_maint_setting_internal_fn (struct gdbarch
*gdbarch
,
2049 const struct language_defn
*language
,
2050 void *cookie
, int argc
, struct value
**argv
)
2052 return value_from_setting (setting_cmd ("$_gdb_maint_setting",
2053 maintenance_show_cmdlist
,
2058 /* Builds a string value from the show CMD. */
2060 static struct value
*
2061 str_value_from_setting (const cmd_list_element
*cmd
, struct gdbarch
*gdbarch
)
2063 switch (cmd
->var_type
)
2068 case var_zuinteger_unlimited
:
2069 case var_auto_boolean
:
2073 std::string cmd_val
= get_setshow_command_value_string (cmd
);
2075 return value_cstring (cmd_val
.c_str (), cmd_val
.size (),
2076 builtin_type (gdbarch
)->builtin_char
);
2080 case var_string_noescape
:
2081 case var_optional_filename
:
2084 /* For these cases, we do not use get_setshow_command_value_string,
2085 as this function handle some characters specially, e.g. by
2086 escaping quotes. So, we directly use the cmd->var string value,
2087 similarly to the value_from_setting code for these cases. */
2088 if (*(char **) cmd
->var
)
2089 return value_cstring (*(char **) cmd
->var
, strlen (*(char **) cmd
->var
),
2090 builtin_type (gdbarch
)->builtin_char
);
2092 return value_cstring ("", 1,
2093 builtin_type (gdbarch
)->builtin_char
);
2096 gdb_assert_not_reached ("bad var_type");
2100 /* Implementation of the convenience function $_gdb_setting_str. */
2102 static struct value
*
2103 gdb_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2104 const struct language_defn
*language
,
2105 void *cookie
, int argc
, struct value
**argv
)
2107 return str_value_from_setting (setting_cmd ("$_gdb_setting_str",
2108 showlist
, argc
, argv
),
2113 /* Implementation of the convenience function $_gdb_maint_setting_str. */
2115 static struct value
*
2116 gdb_maint_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2117 const struct language_defn
*language
,
2118 void *cookie
, int argc
, struct value
**argv
)
2120 return str_value_from_setting (setting_cmd ("$_gdb_maint_setting_str",
2121 maintenance_show_cmdlist
,
2127 _initialize_cli_cmds (void)
2129 struct cmd_list_element
*c
;
2131 /* Define the classes of commands.
2132 They will appear in the help list in alphabetical order. */
2134 add_cmd ("internals", class_maintenance
, _("\
2135 Maintenance commands.\n\
2136 Some gdb commands are provided just for use by gdb maintainers.\n\
2137 These commands are subject to frequent change, and may not be as\n\
2138 well documented as user commands."),
2140 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
2141 add_cmd ("aliases", class_alias
,
2142 _("Aliases of other commands."), &cmdlist
);
2143 add_cmd ("user-defined", class_user
, _("\
2144 User-defined commands.\n\
2145 The commands in this class are those defined by the user.\n\
2146 Use the \"define\" command to define a command."), &cmdlist
);
2147 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
2149 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
2150 add_cmd ("files", class_files
, _("Specifying and examining files."),
2152 add_cmd ("breakpoints", class_breakpoint
,
2153 _("Making program stop at certain points."), &cmdlist
);
2154 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
2155 add_cmd ("stack", class_stack
, _("\
2156 Examining the stack.\n\
2157 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
2158 counting from zero for the innermost (currently executing) frame.\n\n\
2159 At any time gdb identifies one frame as the \"selected\" frame.\n\
2160 Variable lookups are done with respect to the selected frame.\n\
2161 When the program being debugged stops, gdb selects the innermost frame.\n\
2162 The commands below can be used to select other frames by number or address."),
2164 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
2166 /* Define general commands. */
2168 add_com ("pwd", class_files
, pwd_command
, _("\
2169 Print working directory.\n\
2170 This is used for your program as well."));
2172 c
= add_cmd ("cd", class_files
, cd_command
, _("\
2173 Set working directory to DIR for debugger.\n\
2174 The debugger's current working directory specifies where scripts and other\n\
2175 files that can be loaded by GDB are located.\n\
2176 In order to change the inferior's current working directory, the recommended\n\
2177 way is to use the \"set cwd\" command."), &cmdlist
);
2178 set_cmd_completer (c
, filename_completer
);
2180 add_com ("echo", class_support
, echo_command
, _("\
2181 Print a constant string. Give string as argument.\n\
2182 C escape sequences may be used in the argument.\n\
2183 No newline is added at the end of the argument;\n\
2184 use \"\\n\" if you want a newline to be printed.\n\
2185 Since leading and trailing whitespace are ignored in command arguments,\n\
2186 if you want to print some you must use \"\\\" before leading whitespace\n\
2187 to be printed or after trailing whitespace."));
2189 add_setshow_enum_cmd ("script-extension", class_support
,
2190 script_ext_enums
, &script_ext_mode
, _("\
2191 Set mode for script filename extension recognition."), _("\
2192 Show mode for script filename extension recognition."), _("\
2193 off == no filename extension recognition (all sourced files are GDB scripts)\n\
2194 soft == evaluate script according to filename extension, fallback to GDB script"
2196 strict == evaluate script according to filename extension, error if not supported"
2199 show_script_ext_mode
,
2200 &setlist
, &showlist
);
2202 add_com ("quit", class_support
, quit_command
, _("\
2204 Usage: quit [EXPR]\n\
2205 The optional expression EXPR, if present, is evaluated and the result\n\
2206 used as GDB's exit code. The default is zero."));
2207 c
= add_com ("help", class_support
, help_command
,
2208 _("Print list of commands."));
2209 set_cmd_completer (c
, command_completer
);
2210 add_com_alias ("q", "quit", class_support
, 1);
2211 add_com_alias ("h", "help", class_support
, 1);
2213 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
2214 Set verbosity."), _("\
2215 Show verbosity."), NULL
,
2218 &setlist
, &showlist
);
2220 add_prefix_cmd ("history", class_support
, set_history
,
2221 _("Generic command for setting command history parameters."),
2222 &sethistlist
, "set history ", 0, &setlist
);
2223 add_prefix_cmd ("history", class_support
, show_history
,
2224 _("Generic command for showing command history parameters."),
2225 &showhistlist
, "show history ", 0, &showlist
);
2227 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
2228 Set history expansion on command input."), _("\
2229 Show history expansion on command input."), _("\
2230 Without an argument, history expansion is enabled."),
2232 show_history_expansion_p
,
2233 &sethistlist
, &showhistlist
);
2235 add_prefix_cmd ("info", class_info
, info_command
, _("\
2236 Generic command for showing things about the program being debugged."),
2237 &infolist
, "info ", 0, &cmdlist
);
2238 add_com_alias ("i", "info", class_info
, 1);
2239 add_com_alias ("inf", "info", class_info
, 1);
2241 add_com ("complete", class_obscure
, complete_command
,
2242 _("List the completions for the rest of the line as a command."));
2244 add_prefix_cmd ("show", class_info
, show_command
, _("\
2245 Generic command for showing things about the debugger."),
2246 &showlist
, "show ", 0, &cmdlist
);
2247 /* Another way to get at the same thing. */
2248 add_info ("set", show_command
, _("Show all GDB settings."));
2250 c
= add_com ("with", class_vars
, with_command
, _("\
2251 Temporarily set SETTING to VALUE, run COMMAND, and restore SETTING.\n\
2252 Usage: with SETTING [VALUE] [-- COMMAND]\n\
2253 Usage: w SETTING [VALUE] [-- COMMAND]\n\
2254 With no COMMAND, repeats the last executed command.\n\
2256 SETTING is any setting you can change with the \"set\" subcommands.\n\
2258 with language pascal -- print obj\n\
2259 with print elements unlimited -- print obj\n\
2261 You can change multiple settings using nested with, and use\n\
2262 abbreviations for commands and/or values. E.g.:\n\
2263 w la p -- w p el u -- p obj"));
2264 set_cmd_completer_handle_brkchars (c
, with_command_completer
);
2265 add_com_alias ("w", "with", class_vars
, 1);
2267 add_internal_function ("_gdb_setting_str", _("\
2268 $_gdb_setting_str - returns the value of a GDB setting as a string.\n\
2269 Usage: $_gdb_setting_str (setting)\n\
2271 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2272 boolean values are \"off\", \"on\".\n\
2273 Some integer settings accept an unlimited value, returned\n\
2274 as \"unlimited\"."),
2275 gdb_setting_str_internal_fn
, NULL
);
2277 add_internal_function ("_gdb_setting", _("\
2278 $_gdb_setting - returns the value of a GDB setting.\n\
2279 Usage: $_gdb_setting (setting)\n\
2280 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2281 boolean values are \"off\", \"on\".\n\
2282 Some integer settings accept an unlimited value, returned\n\
2283 as 0 or -1 depending on the setting."),
2284 gdb_setting_internal_fn
, NULL
);
2286 add_internal_function ("_gdb_maint_setting_str", _("\
2287 $_gdb_maint_setting_str - returns the value of a GDB maintenance setting as a string.\n\
2288 Usage: $_gdb_maint_setting_str (setting)\n\
2290 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2291 boolean values are \"off\", \"on\".\n\
2292 Some integer settings accept an unlimited value, returned\n\
2293 as \"unlimited\"."),
2294 gdb_maint_setting_str_internal_fn
, NULL
);
2296 add_internal_function ("_gdb_maint_setting", _("\
2297 $_gdb_maint_setting - returns the value of a GDB maintenance setting.\n\
2298 Usage: $_gdb_maint_setting (setting)\n\
2299 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2300 boolean values are \"off\", \"on\".\n\
2301 Some integer settings accept an unlimited value, returned\n\
2302 as 0 or -1 depending on the setting."),
2303 gdb_maint_setting_internal_fn
, NULL
);
2305 add_cmd ("commands", no_set_class
, show_commands
, _("\
2306 Show the history of commands you typed.\n\
2307 You can supply a command number to start with, or a `+' to start after\n\
2308 the previous command number shown."),
2311 add_cmd ("version", no_set_class
, show_version
,
2312 _("Show what version of GDB this is."), &showlist
);
2314 add_cmd ("configuration", no_set_class
, show_configuration
,
2315 _("Show how GDB was configured at build time."), &showlist
);
2317 add_setshow_zinteger_cmd ("remote", no_class
, &remote_debug
, _("\
2318 Set debugging of remote protocol."), _("\
2319 Show debugging of remote protocol."), _("\
2320 When enabled, each packet sent or received with the remote target\n\
2324 &setdebuglist
, &showdebuglist
);
2326 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
2327 &remote_timeout
, _("\
2328 Set timeout limit to wait for target to respond."), _("\
2329 Show timeout limit to wait for target to respond."), _("\
2330 This value is used to set the time limit for gdb to wait for a response\n\
2333 show_remote_timeout
,
2334 &setlist
, &showlist
);
2336 add_prefix_cmd ("debug", no_class
, set_debug
,
2337 _("Generic command for setting gdb debugging flags."),
2338 &setdebuglist
, "set debug ", 0, &setlist
);
2340 add_prefix_cmd ("debug", no_class
, show_debug
,
2341 _("Generic command for showing gdb debugging flags."),
2342 &showdebuglist
, "show debug ", 0, &showlist
);
2344 c
= add_com ("shell", class_support
, shell_command
, _("\
2345 Execute the rest of the line as a shell command.\n\
2346 With no arguments, run an inferior shell."));
2347 set_cmd_completer (c
, filename_completer
);
2349 add_com_alias ("!", "shell", class_support
, 0);
2351 c
= add_com ("edit", class_files
, edit_command
, _("\
2352 Edit specified file or function.\n\
2353 With no argument, edits file containing most recent line listed.\n\
2354 Editing targets can be specified in these ways:\n\
2355 FILE:LINENUM, to edit at that line in that file,\n\
2356 FUNCTION, to edit at the beginning of that function,\n\
2357 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2358 *ADDRESS, to edit at the line containing that address.\n\
2359 Uses EDITOR environment variable contents as editor (or ex as default)."));
2361 c
->completer
= location_completer
;
2363 c
= add_com ("pipe", class_support
, pipe_command
, _("\
2364 Send the output of a gdb command to a shell command.\n\
2365 Usage: | [COMMAND] | SHELL_COMMAND\n\
2366 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2367 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
2368 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2370 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
2372 The -d option indicates to use the string DELIM to separate COMMAND\n\
2373 from SHELL_COMMAND, in alternative to |. This is useful in\n\
2374 case COMMAND contains a | character.\n\
2376 With no COMMAND, repeat the last executed command\n\
2377 and send its output to SHELL_COMMAND."));
2378 set_cmd_completer_handle_brkchars (c
, pipe_command_completer
);
2379 add_com_alias ("|", "pipe", class_support
, 0);
2381 add_com ("list", class_files
, list_command
, _("\
2382 List specified function or line.\n\
2383 With no argument, lists ten more lines after or around previous listing.\n\
2384 \"list -\" lists the ten lines before a previous ten-line listing.\n\
2385 One argument specifies a line, and ten lines are listed around that line.\n\
2386 Two arguments with comma between specify starting and ending lines to list.\n\
2387 Lines can be specified in these ways:\n\
2388 LINENUM, to list around that line in current file,\n\
2389 FILE:LINENUM, to list around that line in that file,\n\
2390 FUNCTION, to list around beginning of that function,\n\
2391 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2392 *ADDRESS, to list around the line containing that address.\n\
2393 With two args, if one is empty, it stands for ten lines away from\n\
2396 By default, when a single location is given, display ten lines.\n\
2397 This can be changed using \"set listsize\", and the current value\n\
2398 can be shown using \"show listsize\"."));
2400 add_com_alias ("l", "list", class_files
, 1);
2403 add_com_alias ("file", "list", class_files
, 1);
2405 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
2406 Disassemble a specified section of memory.\n\
2407 Default is the function surrounding the pc of the selected frame.\n\
2409 With a /m modifier, source lines are included (if available).\n\
2410 This view is \"source centric\": the output is in source line order,\n\
2411 regardless of any optimization that is present. Only the main source file\n\
2412 is displayed, not those of, e.g., any inlined functions.\n\
2413 This modifier hasn't proved useful in practice and is deprecated\n\
2416 With a /s modifier, source lines are included (if available).\n\
2417 This differs from /m in two important respects:\n\
2418 - the output is still in pc address order, and\n\
2419 - file names and contents for all relevant source files are displayed.\n\
2421 With a /r modifier, raw instructions in hex are included.\n\
2423 With a single argument, the function surrounding that address is dumped.\n\
2424 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
2425 in the form of \"start,end\", or \"start,+length\".\n\
2427 Note that the address is interpreted as an expression, not as a location\n\
2428 like in the \"break\" command.\n\
2429 So, for example, if you want to disassemble function bar in file foo.c\n\
2430 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
2431 set_cmd_completer (c
, location_completer
);
2433 c
= add_com ("make", class_support
, make_command
, _("\
2434 Run the ``make'' program using the rest of the line as arguments."));
2435 set_cmd_completer (c
, filename_completer
);
2436 add_cmd ("user", no_class
, show_user
, _("\
2437 Show definitions of non-python/scheme user defined commands.\n\
2438 Argument is the name of the user defined command.\n\
2439 With no argument, show definitions of all user defined commands."), &showlist
);
2440 add_com ("apropos", class_support
, apropos_command
, _("\
2441 Search for commands matching a REGEXP.\n\
2442 Usage: apropos [-v] REGEXP\n\
2443 Flag -v indicates to produce a verbose output, showing full documentation\n\
2444 of the matching commands."));
2446 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
2447 &max_user_call_depth
, _("\
2448 Set the max call depth for non-python/scheme user-defined commands."), _("\
2449 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
2451 show_max_user_call_depth
,
2452 &setlist
, &showlist
);
2454 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
2455 Set tracing of GDB CLI commands."), _("\
2456 Show state of GDB CLI command tracing."), _("\
2457 When 'on', each command is displayed as it is executed."),
2460 &setlist
, &showlist
);
2462 c
= add_com ("alias", class_support
, alias_command
, _("\
2463 Define a new command that is an alias of an existing command.\n\
2464 Usage: alias [-a] [--] ALIAS = COMMAND\n\
2465 ALIAS is the name of the alias command to create.\n\
2466 COMMAND is the command being aliased to.\n\
2467 If \"-a\" is specified, the command is an abbreviation,\n\
2468 and will not appear in help command list output.\n\
2471 Make \"spe\" an alias of \"set print elements\":\n\
2472 alias spe = set print elements\n\
2473 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2474 alias -a set print elms = set print elements"));
2476 const char *source_help_text
= xstrprintf (_("\
2477 Read commands from a file named FILE.\n\
2479 Usage: source [-s] [-v] FILE\n\
2480 -s: search for the script in the source search path,\n\
2481 even if FILE contains directories.\n\
2482 -v: each command in FILE is echoed as it is executed.\n\
2484 Note that the file \"%s\" is read automatically in this way\n\
2485 when GDB is started."), GDBINIT
);
2486 c
= add_cmd ("source", class_support
, source_command
,
2487 source_help_text
, &cmdlist
);
2488 set_cmd_completer (c
, filename_completer
);