3 Copyright (C) 2000-2019 Free Software Foundation, Inc.
4 Copyright (C) 2019 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
));
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
),
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
),
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 struct obj_section
*section
;
1438 CORE_ADDR low
, high
;
1441 gdb_disassembly_flags flags
;
1443 const struct block
*block
= nullptr;
1454 error (_("Missing modifier."));
1456 while (*p
&& ! isspace (*p
))
1461 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1464 flags
|= DISASSEMBLY_RAW_INSN
;
1467 flags
|= DISASSEMBLY_SOURCE
;
1470 error (_("Invalid disassembly modifier."));
1474 p
= skip_spaces (p
);
1477 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1478 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1479 error (_("Cannot specify both /m and /s."));
1483 flags
|= DISASSEMBLY_OMIT_FNAME
;
1484 disassemble_current_function (flags
);
1488 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1490 /* ROCM: get the gdbarch from the objfile, if found */
1491 section
= find_pc_overlay (pc
);
1492 if (section
== NULL
)
1493 section
= find_pc_section (pc
);
1494 if (section
!= NULL
)
1495 gdbarch
= get_objfile_arch (section
->objfile
);
1502 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1503 error (_("No function contains specified address."));
1505 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1508 /* FIXME: cagney/2004-02-07: This should be an observer. */
1509 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1511 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1512 flags
|= DISASSEMBLY_OMIT_FNAME
;
1516 /* Two arguments. */
1519 p
= skip_spaces (p
);
1525 high
= parse_and_eval_address (p
);
1530 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1534 make_command (const char *arg
, int from_tty
)
1537 shell_escape ("make", from_tty
);
1540 std::string cmd
= std::string ("make ") + arg
;
1542 shell_escape (cmd
.c_str (), from_tty
);
1547 show_user (const char *args
, int from_tty
)
1549 struct cmd_list_element
*c
;
1553 const char *comname
= args
;
1555 c
= lookup_cmd (&comname
, cmdlist
, "", 0, 1);
1556 if (!cli_user_command_p (c
))
1557 error (_("Not a user command."));
1558 show_user_1 (c
, "", args
, gdb_stdout
);
1562 for (c
= cmdlist
; c
; c
= c
->next
)
1564 if (cli_user_command_p (c
) || c
->prefixlist
!= NULL
)
1565 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1570 /* Search through names of commands and documentations for a certain
1571 regular expression. */
1574 apropos_command (const char *arg
, int from_tty
)
1576 bool verbose
= arg
&& check_for_argument (&arg
, "-v", 2);
1578 if (arg
== NULL
|| *arg
== '\0')
1579 error (_("REGEXP string is empty"));
1581 compiled_regex
pattern (arg
, REG_ICASE
,
1582 _("Error in regular expression"));
1584 apropos_cmd (gdb_stdout
, cmdlist
, verbose
, pattern
, "");
1587 /* Subroutine of alias_command to simplify it.
1588 Return the first N elements of ARGV flattened back to a string
1589 with a space separating each element.
1590 ARGV may not be NULL.
1591 This does not take care of quoting elements in case they contain spaces
1595 argv_to_string (char **argv
, int n
)
1600 gdb_assert (argv
!= NULL
);
1601 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1603 for (i
= 0; i
< n
; ++i
)
1613 /* Subroutine of alias_command to simplify it.
1614 Return true if COMMAND exists, unambiguously. Otherwise false. */
1617 valid_command_p (const char *command
)
1619 struct cmd_list_element
*c
;
1621 c
= lookup_cmd_1 (& command
, cmdlist
, NULL
, 1);
1623 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1626 /* This is the slightly tricky part.
1627 lookup_cmd_1 will return a pointer to the last part of COMMAND
1628 to match, leaving COMMAND pointing at the remainder. */
1629 while (*command
== ' ' || *command
== '\t')
1631 return *command
== '\0';
1634 /* Called when "alias" was incorrectly used. */
1637 alias_usage_error (void)
1639 error (_("Usage: alias [-a] [--] ALIAS = COMMAND"));
1642 /* Make an alias of an existing command. */
1645 alias_command (const char *args
, int from_tty
)
1647 int i
, alias_argc
, command_argc
;
1648 int abbrev_flag
= 0;
1650 const char *alias
, *command
;
1652 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1653 alias_usage_error ();
1655 equals
= strchr (args
, '=');
1656 std::string
args2 (args
, equals
- args
);
1658 gdb_argv
built_alias_argv (args2
.c_str ());
1659 gdb_argv
command_argv (equals
+ 1);
1661 char **alias_argv
= built_alias_argv
.get ();
1662 while (alias_argv
[0] != NULL
)
1664 if (strcmp (alias_argv
[0], "-a") == 0)
1669 else if (strcmp (alias_argv
[0], "--") == 0)
1678 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1679 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1680 alias_usage_error ();
1682 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1684 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1687 error (_("Invalid command name: %s"), alias_argv
[i
]);
1689 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1693 alias_argc
= countargv (alias_argv
);
1694 command_argc
= command_argv
.count ();
1696 /* COMMAND must exist.
1697 Reconstruct the command to remove any extraneous spaces,
1698 for better error messages. */
1699 std::string
command_string (argv_to_string (command_argv
.get (),
1701 command
= command_string
.c_str ();
1702 if (! valid_command_p (command
))
1703 error (_("Invalid command to alias to: %s"), command
);
1705 /* ALIAS must not exist. */
1706 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1707 alias
= alias_string
.c_str ();
1708 if (valid_command_p (alias
))
1709 error (_("Alias already exists: %s"), alias
);
1711 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1712 Example: alias spe = set print elements
1714 Otherwise ALIAS and COMMAND must have the same number of words,
1715 and every word except the last must identify the same prefix command;
1716 and the last word of ALIAS is made an alias of the last word of COMMAND.
1717 Example: alias set print elms = set pr elem
1718 Note that unambiguous abbreviations are allowed. */
1720 if (alias_argc
== 1)
1722 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1723 add_com_alias (xstrdup (alias_argv
[0]), command
, class_alias
,
1728 const char *alias_prefix
, *command_prefix
;
1729 struct cmd_list_element
*c_alias
, *c_command
;
1731 if (alias_argc
!= command_argc
)
1732 error (_("Mismatched command length between ALIAS and COMMAND."));
1734 /* Create copies of ALIAS and COMMAND without the last word,
1735 and use that to verify the leading elements give the same
1737 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1739 std::string
command_prefix_string (argv_to_string (command_argv
.get (),
1741 alias_prefix
= alias_prefix_string
.c_str ();
1742 command_prefix
= command_prefix_string
.c_str ();
1744 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, 1);
1745 /* We've already tried to look up COMMAND. */
1746 gdb_assert (c_command
!= NULL
1747 && c_command
!= (struct cmd_list_element
*) -1);
1748 gdb_assert (c_command
->prefixlist
!= NULL
);
1749 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, 1);
1750 if (c_alias
!= c_command
)
1751 error (_("ALIAS and COMMAND prefixes do not match."));
1753 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1754 add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1755 command_argv
[command_argc
- 1],
1756 class_alias
, abbrev_flag
, c_command
->prefixlist
);
1760 /* Print the file / line number / symbol name of the location
1761 specified by SAL. */
1764 print_sal_location (const symtab_and_line
&sal
)
1766 scoped_restore_current_program_space restore_pspace
;
1767 set_current_program_space (sal
.pspace
);
1769 const char *sym_name
= NULL
;
1770 if (sal
.symbol
!= NULL
)
1771 sym_name
= sal
.symbol
->print_name ();
1772 printf_filtered (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
1773 symtab_to_filename_for_display (sal
.symtab
),
1774 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
1777 /* Print a list of files and line numbers which a user may choose from
1778 in order to list a function which was specified ambiguously (as
1779 with `list classname::overloadedfuncname', for example). The SALS
1780 array provides the filenames and line numbers. FORMAT is a
1781 printf-style format string used to tell the user what was
1785 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
1786 const char *format
, ...)
1789 va_start (ap
, format
);
1790 vprintf_filtered (format
, ap
);
1793 for (const auto &sal
: sals
)
1794 print_sal_location (sal
);
1797 /* Comparison function for filter_sals. Returns a qsort-style
1801 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1803 const char *dira
= SYMTAB_DIRNAME (sala
.symtab
);
1804 const char *dirb
= SYMTAB_DIRNAME (salb
.symtab
);
1812 else if (dirb
== NULL
)
1819 r
= filename_cmp (dira
, dirb
);
1824 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
1828 if (sala
.line
< salb
.line
)
1830 return sala
.line
== salb
.line
? 0 : 1;
1833 /* Remove any SALs that do not match the current program space, or
1834 which appear to be "file:line" duplicates. */
1837 filter_sals (std::vector
<symtab_and_line
> &sals
)
1839 /* Remove SALs that do not match. */
1840 auto from
= std::remove_if (sals
.begin (), sals
.end (),
1841 [&] (const symtab_and_line
&sal
)
1842 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
1845 std::sort (sals
.begin (), from
,
1846 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1847 { return cmp_symtabs (sala
, salb
) < 0; });
1849 from
= std::unique (sals
.begin (), from
,
1850 [&] (const symtab_and_line
&sala
,
1851 const symtab_and_line
&salb
)
1852 { return cmp_symtabs (sala
, salb
) == 0; });
1854 sals
.erase (from
, sals
.end ());
1858 set_debug (const char *arg
, int from_tty
)
1860 printf_unfiltered (_("\"set debug\" must be followed by "
1861 "the name of a debug subcommand.\n"));
1862 help_list (setdebuglist
, "set debug ", all_commands
, gdb_stdout
);
1866 show_debug (const char *args
, int from_tty
)
1868 cmd_show_list (showdebuglist
, from_tty
, "");
1872 init_cmd_lists (void)
1874 max_user_call_depth
= 1024;
1878 show_info_verbose (struct ui_file
*file
, int from_tty
,
1879 struct cmd_list_element
*c
,
1883 fprintf_filtered (file
,
1884 _("Verbose printing of informational messages is %s.\n"),
1887 fprintf_filtered (file
, _("Verbosity is %s.\n"), value
);
1891 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
1892 struct cmd_list_element
*c
, const char *value
)
1894 fprintf_filtered (file
, _("History expansion on command input is %s.\n"),
1899 show_remote_debug (struct ui_file
*file
, int from_tty
,
1900 struct cmd_list_element
*c
, const char *value
)
1902 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
1907 show_remote_timeout (struct ui_file
*file
, int from_tty
,
1908 struct cmd_list_element
*c
, const char *value
)
1910 fprintf_filtered (file
,
1911 _("Timeout limit to wait for target to respond is %s.\n"),
1916 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
1917 struct cmd_list_element
*c
, const char *value
)
1919 fprintf_filtered (file
,
1920 _("The max call depth for user-defined commands is %s.\n"),
1924 /* Returns the cmd_list_element in SHOWLIST corresponding to the first
1925 argument of ARGV, which must contain one single value.
1926 Throws an error if no value provided, or value not correct.
1927 FNNAME is used in the error message. */
1929 static cmd_list_element
*
1930 setting_cmd (const char *fnname
, struct cmd_list_element
*showlist
,
1931 int argc
, struct value
**argv
)
1934 error (_("You must provide an argument to %s"), fnname
);
1936 error (_("You can only provide one argument to %s"), fnname
);
1938 struct type
*type0
= check_typedef (value_type (argv
[0]));
1940 if (TYPE_CODE (type0
) != TYPE_CODE_ARRAY
1941 && TYPE_CODE (type0
) != TYPE_CODE_STRING
)
1942 error (_("First argument of %s must be a string."), fnname
);
1944 const char *a0
= (const char *) value_contents (argv
[0]);
1945 cmd_list_element
*cmd
= lookup_cmd (&a0
, showlist
, "", -1, 0);
1947 if (cmd
== nullptr || cmd_type (cmd
) != show_cmd
)
1948 error (_("First argument of %s must be a "
1949 "valid setting of the 'show' command."), fnname
);
1954 /* Builds a value from the show CMD. */
1956 static struct value
*
1957 value_from_setting (const cmd_list_element
*cmd
, struct gdbarch
*gdbarch
)
1959 switch (cmd
->var_type
)
1962 if (*(int *) cmd
->var
== INT_MAX
)
1963 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1966 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1969 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1972 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1973 *(bool *) cmd
->var
? 1 : 0);
1974 case var_zuinteger_unlimited
:
1975 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1977 case var_auto_boolean
:
1981 switch (*(enum auto_boolean
*) cmd
->var
)
1983 case AUTO_BOOLEAN_TRUE
:
1986 case AUTO_BOOLEAN_FALSE
:
1989 case AUTO_BOOLEAN_AUTO
:
1993 gdb_assert_not_reached ("invalid var_auto_boolean");
1995 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1999 if (*(unsigned int *) cmd
->var
== UINT_MAX
)
2000 return value_from_ulongest
2001 (builtin_type (gdbarch
)->builtin_unsigned_int
, 0);
2003 return value_from_ulongest
2004 (builtin_type (gdbarch
)->builtin_unsigned_int
,
2005 *(unsigned int *) cmd
->var
);
2007 return value_from_ulongest (builtin_type (gdbarch
)->builtin_unsigned_int
,
2008 *(unsigned int *) cmd
->var
);
2010 case var_string_noescape
:
2011 case var_optional_filename
:
2014 if (*(char **) cmd
->var
)
2015 return value_cstring (*(char **) cmd
->var
, strlen (*(char **) cmd
->var
),
2016 builtin_type (gdbarch
)->builtin_char
);
2018 return value_cstring ("", 1,
2019 builtin_type (gdbarch
)->builtin_char
);
2021 gdb_assert_not_reached ("bad var_type");
2025 /* Implementation of the convenience function $_gdb_setting. */
2027 static struct value
*
2028 gdb_setting_internal_fn (struct gdbarch
*gdbarch
,
2029 const struct language_defn
*language
,
2030 void *cookie
, int argc
, struct value
**argv
)
2032 return value_from_setting (setting_cmd ("$_gdb_setting", showlist
,
2037 /* Implementation of the convenience function $_gdb_maint_setting. */
2039 static struct value
*
2040 gdb_maint_setting_internal_fn (struct gdbarch
*gdbarch
,
2041 const struct language_defn
*language
,
2042 void *cookie
, int argc
, struct value
**argv
)
2044 return value_from_setting (setting_cmd ("$_gdb_maint_setting",
2045 maintenance_show_cmdlist
,
2050 /* Builds a string value from the show CMD. */
2052 static struct value
*
2053 str_value_from_setting (const cmd_list_element
*cmd
, struct gdbarch
*gdbarch
)
2055 switch (cmd
->var_type
)
2060 case var_zuinteger_unlimited
:
2061 case var_auto_boolean
:
2065 std::string cmd_val
= get_setshow_command_value_string (cmd
);
2067 return value_cstring (cmd_val
.c_str (), cmd_val
.size (),
2068 builtin_type (gdbarch
)->builtin_char
);
2072 case var_string_noescape
:
2073 case var_optional_filename
:
2076 /* For these cases, we do not use get_setshow_command_value_string,
2077 as this function handle some characters specially, e.g. by
2078 escaping quotes. So, we directly use the cmd->var string value,
2079 similarly to the value_from_setting code for these cases. */
2080 if (*(char **) cmd
->var
)
2081 return value_cstring (*(char **) cmd
->var
, strlen (*(char **) cmd
->var
),
2082 builtin_type (gdbarch
)->builtin_char
);
2084 return value_cstring ("", 1,
2085 builtin_type (gdbarch
)->builtin_char
);
2088 gdb_assert_not_reached ("bad var_type");
2092 /* Implementation of the convenience function $_gdb_setting_str. */
2094 static struct value
*
2095 gdb_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2096 const struct language_defn
*language
,
2097 void *cookie
, int argc
, struct value
**argv
)
2099 return str_value_from_setting (setting_cmd ("$_gdb_setting_str",
2100 showlist
, argc
, argv
),
2105 /* Implementation of the convenience function $_gdb_maint_setting_str. */
2107 static struct value
*
2108 gdb_maint_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2109 const struct language_defn
*language
,
2110 void *cookie
, int argc
, struct value
**argv
)
2112 return str_value_from_setting (setting_cmd ("$_gdb_maint_setting_str",
2113 maintenance_show_cmdlist
,
2119 _initialize_cli_cmds (void)
2121 struct cmd_list_element
*c
;
2123 /* Define the classes of commands.
2124 They will appear in the help list in alphabetical order. */
2126 add_cmd ("internals", class_maintenance
, _("\
2127 Maintenance commands.\n\
2128 Some gdb commands are provided just for use by gdb maintainers.\n\
2129 These commands are subject to frequent change, and may not be as\n\
2130 well documented as user commands."),
2132 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
2133 add_cmd ("aliases", class_alias
,
2134 _("Aliases of other commands."), &cmdlist
);
2135 add_cmd ("user-defined", class_user
, _("\
2136 User-defined commands.\n\
2137 The commands in this class are those defined by the user.\n\
2138 Use the \"define\" command to define a command."), &cmdlist
);
2139 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
2141 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
2142 add_cmd ("files", class_files
, _("Specifying and examining files."),
2144 add_cmd ("breakpoints", class_breakpoint
,
2145 _("Making program stop at certain points."), &cmdlist
);
2146 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
2147 add_cmd ("stack", class_stack
, _("\
2148 Examining the stack.\n\
2149 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
2150 counting from zero for the innermost (currently executing) frame.\n\n\
2151 At any time gdb identifies one frame as the \"selected\" frame.\n\
2152 Variable lookups are done with respect to the selected frame.\n\
2153 When the program being debugged stops, gdb selects the innermost frame.\n\
2154 The commands below can be used to select other frames by number or address."),
2156 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
2158 /* Define general commands. */
2160 add_com ("pwd", class_files
, pwd_command
, _("\
2161 Print working directory.\n\
2162 This is used for your program as well."));
2164 c
= add_cmd ("cd", class_files
, cd_command
, _("\
2165 Set working directory to DIR for debugger.\n\
2166 The debugger's current working directory specifies where scripts and other\n\
2167 files that can be loaded by GDB are located.\n\
2168 In order to change the inferior's current working directory, the recommended\n\
2169 way is to use the \"set cwd\" command."), &cmdlist
);
2170 set_cmd_completer (c
, filename_completer
);
2172 add_com ("echo", class_support
, echo_command
, _("\
2173 Print a constant string. Give string as argument.\n\
2174 C escape sequences may be used in the argument.\n\
2175 No newline is added at the end of the argument;\n\
2176 use \"\\n\" if you want a newline to be printed.\n\
2177 Since leading and trailing whitespace are ignored in command arguments,\n\
2178 if you want to print some you must use \"\\\" before leading whitespace\n\
2179 to be printed or after trailing whitespace."));
2181 add_setshow_enum_cmd ("script-extension", class_support
,
2182 script_ext_enums
, &script_ext_mode
, _("\
2183 Set mode for script filename extension recognition."), _("\
2184 Show mode for script filename extension recognition."), _("\
2185 off == no filename extension recognition (all sourced files are GDB scripts)\n\
2186 soft == evaluate script according to filename extension, fallback to GDB script"
2188 strict == evaluate script according to filename extension, error if not supported"
2191 show_script_ext_mode
,
2192 &setlist
, &showlist
);
2194 add_com ("quit", class_support
, quit_command
, _("\
2196 Usage: quit [EXPR]\n\
2197 The optional expression EXPR, if present, is evaluated and the result\n\
2198 used as GDB's exit code. The default is zero."));
2199 c
= add_com ("help", class_support
, help_command
,
2200 _("Print list of commands."));
2201 set_cmd_completer (c
, command_completer
);
2202 add_com_alias ("q", "quit", class_support
, 1);
2203 add_com_alias ("h", "help", class_support
, 1);
2205 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
2206 Set verbosity."), _("\
2207 Show verbosity."), NULL
,
2210 &setlist
, &showlist
);
2212 add_prefix_cmd ("history", class_support
, set_history
,
2213 _("Generic command for setting command history parameters."),
2214 &sethistlist
, "set history ", 0, &setlist
);
2215 add_prefix_cmd ("history", class_support
, show_history
,
2216 _("Generic command for showing command history parameters."),
2217 &showhistlist
, "show history ", 0, &showlist
);
2219 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
2220 Set history expansion on command input."), _("\
2221 Show history expansion on command input."), _("\
2222 Without an argument, history expansion is enabled."),
2224 show_history_expansion_p
,
2225 &sethistlist
, &showhistlist
);
2227 add_prefix_cmd ("info", class_info
, info_command
, _("\
2228 Generic command for showing things about the program being debugged."),
2229 &infolist
, "info ", 0, &cmdlist
);
2230 add_com_alias ("i", "info", class_info
, 1);
2231 add_com_alias ("inf", "info", class_info
, 1);
2233 add_com ("complete", class_obscure
, complete_command
,
2234 _("List the completions for the rest of the line as a command."));
2236 add_prefix_cmd ("show", class_info
, show_command
, _("\
2237 Generic command for showing things about the debugger."),
2238 &showlist
, "show ", 0, &cmdlist
);
2239 /* Another way to get at the same thing. */
2240 add_info ("set", show_command
, _("Show all GDB settings."));
2242 c
= add_com ("with", class_vars
, with_command
, _("\
2243 Temporarily set SETTING to VALUE, run COMMAND, and restore SETTING.\n\
2244 Usage: with SETTING [VALUE] [-- COMMAND]\n\
2245 Usage: w SETTING [VALUE] [-- COMMAND]\n\
2246 With no COMMAND, repeats the last executed command.\n\
2248 SETTING is any setting you can change with the \"set\" subcommands.\n\
2250 with language pascal -- print obj\n\
2251 with print elements unlimited -- print obj\n\
2253 You can change multiple settings using nested with, and use\n\
2254 abbreviations for commands and/or values. E.g.:\n\
2255 w la p -- w p el u -- p obj"));
2256 set_cmd_completer_handle_brkchars (c
, with_command_completer
);
2257 add_com_alias ("w", "with", class_vars
, 1);
2259 add_internal_function ("_gdb_setting_str", _("\
2260 $_gdb_setting_str - returns the value of a GDB setting as a string.\n\
2261 Usage: $_gdb_setting_str (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 \"unlimited\"."),
2267 gdb_setting_str_internal_fn
, NULL
);
2269 add_internal_function ("_gdb_setting", _("\
2270 $_gdb_setting - returns the value of a GDB setting.\n\
2271 Usage: $_gdb_setting (setting)\n\
2272 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2273 boolean values are \"off\", \"on\".\n\
2274 Some integer settings accept an unlimited value, returned\n\
2275 as 0 or -1 depending on the setting."),
2276 gdb_setting_internal_fn
, NULL
);
2278 add_internal_function ("_gdb_maint_setting_str", _("\
2279 $_gdb_maint_setting_str - returns the value of a GDB maintenance setting as a string.\n\
2280 Usage: $_gdb_maint_setting_str (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 \"unlimited\"."),
2286 gdb_maint_setting_str_internal_fn
, NULL
);
2288 add_internal_function ("_gdb_maint_setting", _("\
2289 $_gdb_maint_setting - returns the value of a GDB maintenance setting.\n\
2290 Usage: $_gdb_maint_setting (setting)\n\
2291 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2292 boolean values are \"off\", \"on\".\n\
2293 Some integer settings accept an unlimited value, returned\n\
2294 as 0 or -1 depending on the setting."),
2295 gdb_maint_setting_internal_fn
, NULL
);
2297 add_cmd ("commands", no_set_class
, show_commands
, _("\
2298 Show the history of commands you typed.\n\
2299 You can supply a command number to start with, or a `+' to start after\n\
2300 the previous command number shown."),
2303 add_cmd ("version", no_set_class
, show_version
,
2304 _("Show what version of GDB this is."), &showlist
);
2306 add_cmd ("configuration", no_set_class
, show_configuration
,
2307 _("Show how GDB was configured at build time."), &showlist
);
2309 add_setshow_zinteger_cmd ("remote", no_class
, &remote_debug
, _("\
2310 Set debugging of remote protocol."), _("\
2311 Show debugging of remote protocol."), _("\
2312 When enabled, each packet sent or received with the remote target\n\
2316 &setdebuglist
, &showdebuglist
);
2318 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
2319 &remote_timeout
, _("\
2320 Set timeout limit to wait for target to respond."), _("\
2321 Show timeout limit to wait for target to respond."), _("\
2322 This value is used to set the time limit for gdb to wait for a response\n\
2325 show_remote_timeout
,
2326 &setlist
, &showlist
);
2328 add_prefix_cmd ("debug", no_class
, set_debug
,
2329 _("Generic command for setting gdb debugging flags."),
2330 &setdebuglist
, "set debug ", 0, &setlist
);
2332 add_prefix_cmd ("debug", no_class
, show_debug
,
2333 _("Generic command for showing gdb debugging flags."),
2334 &showdebuglist
, "show debug ", 0, &showlist
);
2336 c
= add_com ("shell", class_support
, shell_command
, _("\
2337 Execute the rest of the line as a shell command.\n\
2338 With no arguments, run an inferior shell."));
2339 set_cmd_completer (c
, filename_completer
);
2341 add_com_alias ("!", "shell", class_support
, 0);
2343 c
= add_com ("edit", class_files
, edit_command
, _("\
2344 Edit specified file or function.\n\
2345 With no argument, edits file containing most recent line listed.\n\
2346 Editing targets can be specified in these ways:\n\
2347 FILE:LINENUM, to edit at that line in that file,\n\
2348 FUNCTION, to edit at the beginning of that function,\n\
2349 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2350 *ADDRESS, to edit at the line containing that address.\n\
2351 Uses EDITOR environment variable contents as editor (or ex as default)."));
2353 c
->completer
= location_completer
;
2355 c
= add_com ("pipe", class_support
, pipe_command
, _("\
2356 Send the output of a gdb command to a shell command.\n\
2357 Usage: | [COMMAND] | SHELL_COMMAND\n\
2358 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2359 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
2360 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2362 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
2364 The -d option indicates to use the string DELIM to separate COMMAND\n\
2365 from SHELL_COMMAND, in alternative to |. This is useful in\n\
2366 case COMMAND contains a | character.\n\
2368 With no COMMAND, repeat the last executed command\n\
2369 and send its output to SHELL_COMMAND."));
2370 set_cmd_completer_handle_brkchars (c
, pipe_command_completer
);
2371 add_com_alias ("|", "pipe", class_support
, 0);
2373 add_com ("list", class_files
, list_command
, _("\
2374 List specified function or line.\n\
2375 With no argument, lists ten more lines after or around previous listing.\n\
2376 \"list -\" lists the ten lines before a previous ten-line listing.\n\
2377 One argument specifies a line, and ten lines are listed around that line.\n\
2378 Two arguments with comma between specify starting and ending lines to list.\n\
2379 Lines can be specified in these ways:\n\
2380 LINENUM, to list around that line in current file,\n\
2381 FILE:LINENUM, to list around that line in that file,\n\
2382 FUNCTION, to list around beginning of that function,\n\
2383 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2384 *ADDRESS, to list around the line containing that address.\n\
2385 With two args, if one is empty, it stands for ten lines away from\n\
2388 By default, when a single location is given, display ten lines.\n\
2389 This can be changed using \"set listsize\", and the current value\n\
2390 can be shown using \"show listsize\"."));
2392 add_com_alias ("l", "list", class_files
, 1);
2395 add_com_alias ("file", "list", class_files
, 1);
2397 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
2398 Disassemble a specified section of memory.\n\
2399 Default is the function surrounding the pc of the selected frame.\n\
2401 With a /m modifier, source lines are included (if available).\n\
2402 This view is \"source centric\": the output is in source line order,\n\
2403 regardless of any optimization that is present. Only the main source file\n\
2404 is displayed, not those of, e.g., any inlined functions.\n\
2405 This modifier hasn't proved useful in practice and is deprecated\n\
2408 With a /s modifier, source lines are included (if available).\n\
2409 This differs from /m in two important respects:\n\
2410 - the output is still in pc address order, and\n\
2411 - file names and contents for all relevant source files are displayed.\n\
2413 With a /r modifier, raw instructions in hex are included.\n\
2415 With a single argument, the function surrounding that address is dumped.\n\
2416 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
2417 in the form of \"start,end\", or \"start,+length\".\n\
2419 Note that the address is interpreted as an expression, not as a location\n\
2420 like in the \"break\" command.\n\
2421 So, for example, if you want to disassemble function bar in file foo.c\n\
2422 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
2423 set_cmd_completer (c
, location_completer
);
2425 c
= add_com ("make", class_support
, make_command
, _("\
2426 Run the ``make'' program using the rest of the line as arguments."));
2427 set_cmd_completer (c
, filename_completer
);
2428 add_cmd ("user", no_class
, show_user
, _("\
2429 Show definitions of non-python/scheme user defined commands.\n\
2430 Argument is the name of the user defined command.\n\
2431 With no argument, show definitions of all user defined commands."), &showlist
);
2432 add_com ("apropos", class_support
, apropos_command
, _("\
2433 Search for commands matching a REGEXP.\n\
2434 Usage: apropos [-v] REGEXP\n\
2435 Flag -v indicates to produce a verbose output, showing full documentation\n\
2436 of the matching commands."));
2438 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
2439 &max_user_call_depth
, _("\
2440 Set the max call depth for non-python/scheme user-defined commands."), _("\
2441 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
2443 show_max_user_call_depth
,
2444 &setlist
, &showlist
);
2446 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
2447 Set tracing of GDB CLI commands."), _("\
2448 Show state of GDB CLI command tracing."), _("\
2449 When 'on', each command is displayed as it is executed."),
2452 &setlist
, &showlist
);
2454 c
= add_com ("alias", class_support
, alias_command
, _("\
2455 Define a new command that is an alias of an existing command.\n\
2456 Usage: alias [-a] [--] ALIAS = COMMAND\n\
2457 ALIAS is the name of the alias command to create.\n\
2458 COMMAND is the command being aliased to.\n\
2459 If \"-a\" is specified, the command is an abbreviation,\n\
2460 and will not appear in help command list output.\n\
2463 Make \"spe\" an alias of \"set print elements\":\n\
2464 alias spe = set print elements\n\
2465 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2466 alias -a set print elms = set print elements"));
2468 const char *source_help_text
= xstrprintf (_("\
2469 Read commands from a file named FILE.\n\
2471 Usage: source [-s] [-v] FILE\n\
2472 -s: search for the script in the source search path,\n\
2473 even if FILE contains directories.\n\
2474 -v: each command in FILE is echoed as it is executed.\n\
2476 Note that the file \"%s\" is read automatically in this way\n\
2477 when GDB is started."), GDBINIT
);
2478 c
= add_cmd ("source", class_support
, source_command
,
2479 source_help_text
, &cmdlist
);
2480 set_cmd_completer (c
, filename_completer
);