3 Copyright (C) 2000-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
22 #include "readline/tilde.h"
23 #include "completer.h"
24 #include "target.h" /* For baud_rate, remote_debug and remote_timeout. */
25 #include "gdbsupport/gdb_wait.h" /* For shell escape implementation. */
27 #include "gdb_regex.h" /* Used by apropos_command. */
28 #include "gdb_vfork.h"
30 #include "expression.h"
34 #include "filenames.h" /* For DOSish file names. */
38 #include "tracepoint.h"
39 #include "gdbsupport/filestuff.h"
47 #include "cli/cli-decode.h"
48 #include "cli/cli-script.h"
49 #include "cli/cli-setshow.h"
50 #include "cli/cli-cmds.h"
51 #include "cli/cli-style.h"
52 #include "cli/cli-utils.h"
54 #include "extension.h"
55 #include "gdbsupport/pathstuff.h"
58 #include "tui/tui.h" /* For tui_active et.al. */
65 /* Prototypes for local utility functions */
67 static void print_sal_location (const symtab_and_line
&sal
);
69 static void ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
70 const char *format
, ...)
71 ATTRIBUTE_PRINTF (2, 3);
73 static void filter_sals (std::vector
<symtab_and_line
> &);
77 unsigned int max_user_call_depth
;
79 /* Define all cmd_list_elements. */
81 /* Chain containing all defined commands. */
83 struct cmd_list_element
*cmdlist
;
85 /* Chain containing all defined info subcommands. */
87 struct cmd_list_element
*infolist
;
89 /* Chain containing all defined enable subcommands. */
91 struct cmd_list_element
*enablelist
;
93 /* Chain containing all defined disable subcommands. */
95 struct cmd_list_element
*disablelist
;
97 /* Chain containing all defined stop subcommands. */
99 struct cmd_list_element
*stoplist
;
101 /* Chain containing all defined delete subcommands. */
103 struct cmd_list_element
*deletelist
;
105 /* Chain containing all defined detach subcommands. */
107 struct cmd_list_element
*detachlist
;
109 /* Chain containing all defined kill subcommands. */
111 struct cmd_list_element
*killlist
;
113 /* Chain containing all defined set subcommands */
115 struct cmd_list_element
*setlist
;
117 /* Chain containing all defined unset subcommands */
119 struct cmd_list_element
*unsetlist
;
121 /* Chain containing all defined show subcommands. */
123 struct cmd_list_element
*showlist
;
125 /* Chain containing all defined \"set history\". */
127 struct cmd_list_element
*sethistlist
;
129 /* Chain containing all defined \"show history\". */
131 struct cmd_list_element
*showhistlist
;
133 /* Chain containing all defined \"unset history\". */
135 struct cmd_list_element
*unsethistlist
;
137 /* Chain containing all defined maintenance subcommands. */
139 struct cmd_list_element
*maintenancelist
;
141 /* Chain containing all defined "maintenance info" subcommands. */
143 struct cmd_list_element
*maintenanceinfolist
;
145 /* Chain containing all defined "maintenance print" subcommands. */
147 struct cmd_list_element
*maintenanceprintlist
;
149 /* Chain containing all defined "maintenance check" subcommands. */
151 struct cmd_list_element
*maintenancechecklist
;
153 struct cmd_list_element
*setprintlist
;
155 struct cmd_list_element
*showprintlist
;
157 struct cmd_list_element
*setdebuglist
;
159 struct cmd_list_element
*showdebuglist
;
161 struct cmd_list_element
*setchecklist
;
163 struct cmd_list_element
*showchecklist
;
165 /* Command tracing state. */
167 int source_verbose
= 0;
168 bool trace_commands
= false;
170 /* 'script-extension' option support. */
172 static const char script_ext_off
[] = "off";
173 static const char script_ext_soft
[] = "soft";
174 static const char script_ext_strict
[] = "strict";
176 static const char *const script_ext_enums
[] = {
183 static const char *script_ext_mode
= script_ext_soft
;
185 /* Utility used everywhere when at least one argument is needed and
189 error_no_arg (const char *why
)
191 error (_("Argument required (%s)."), why
);
194 /* The "info" command is defined as a prefix, with allow_unknown = 0.
195 Therefore, its own definition is called only for "info" with no
199 info_command (const char *arg
, int from_tty
)
201 printf_unfiltered (_("\"info\" must be followed by "
202 "the name of an info command.\n"));
203 help_list (infolist
, "info ", all_commands
, gdb_stdout
);
206 /* The "show" command with no arguments shows all the settings. */
209 show_command (const char *arg
, int from_tty
)
211 cmd_show_list (showlist
, from_tty
, "");
214 /* See cli/cli-cmds.h. */
217 with_command_1 (const char *set_cmd_prefix
,
218 cmd_list_element
*setlist
, const char *args
, int from_tty
)
221 error (_("Missing arguments."));
223 const char *delim
= strstr (args
, "--");
224 const char *nested_cmd
= nullptr;
227 error (_("Missing setting before '--' delimiter"));
229 if (delim
== nullptr || *skip_spaces (&delim
[2]) == '\0')
230 nested_cmd
= repeat_previous ();
232 cmd_list_element
*set_cmd
= lookup_cmd (&args
, setlist
, set_cmd_prefix
,
233 /*allow_unknown=*/ 0,
234 /*ignore_help_classes=*/ 1);
235 gdb_assert (set_cmd
!= nullptr);
237 if (set_cmd
->var
== nullptr)
238 error (_("Cannot use this setting with the \"with\" command"));
240 std::string temp_value
241 = (delim
== nullptr ? args
: std::string (args
, delim
- args
));
243 if (nested_cmd
== nullptr)
244 nested_cmd
= skip_spaces (delim
+ 2);
246 std::string org_value
= get_setshow_command_value_string (set_cmd
);
248 /* Tweak the setting to the new temporary value. */
249 do_set_command (temp_value
.c_str (), from_tty
, set_cmd
);
253 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
255 /* Execute the nested command. */
256 execute_command (nested_cmd
, from_tty
);
258 catch (const gdb_exception
&ex
)
260 /* Restore the setting and rethrow. If restoring the setting
261 throws, swallow the new exception and warn. There's nothing
262 else we can reasonably do. */
265 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
267 catch (const gdb_exception
&ex2
)
269 warning (_("Couldn't restore setting: %s"), ex2
.what ());
275 /* Restore the setting. */
276 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
279 /* See cli/cli-cmds.h. */
282 with_command_completer_1 (const char *set_cmd_prefix
,
283 completion_tracker
&tracker
,
286 tracker
.set_use_custom_word_point (true);
288 const char *delim
= strstr (text
, "--");
290 /* If we're still not past the "--" delimiter, complete the "with"
291 command as if it was a "set" command. */
294 || !isspace (delim
[-1])
295 || !(isspace (delim
[2]) || delim
[2] == '\0'))
297 std::string new_text
= std::string (set_cmd_prefix
) + text
;
298 tracker
.advance_custom_word_point_by (-(int) strlen (set_cmd_prefix
));
299 complete_nested_command_line (tracker
, new_text
.c_str ());
303 /* We're past the "--" delimiter. Complete on the sub command. */
304 const char *nested_cmd
= skip_spaces (delim
+ 2);
305 tracker
.advance_custom_word_point_by (nested_cmd
- text
);
306 complete_nested_command_line (tracker
, nested_cmd
);
309 /* The "with" command. */
312 with_command (const char *args
, int from_tty
)
314 with_command_1 ("set ", setlist
, args
, from_tty
);
317 /* "with" command completer. */
320 with_command_completer (struct cmd_list_element
*ignore
,
321 completion_tracker
&tracker
,
322 const char *text
, const char * /*word*/)
324 with_command_completer_1 ("set ", tracker
, text
);
328 /* Provide documentation on command or list given by COMMAND. FROM_TTY
332 help_command (const char *command
, int from_tty
)
334 help_cmd (command
, gdb_stdout
);
338 /* Note: The "complete" command is used by Emacs to implement completion.
339 [Is that why this function writes output with *_unfiltered?] */
342 complete_command (const char *arg
, int from_tty
)
346 if (max_completions
== 0)
348 /* Only print this for non-mi frontends. An MI frontend may not
349 be able to handle this. */
350 if (!current_uiout
->is_mi_like_p ())
352 printf_unfiltered (_("max-completions is zero,"
353 " completion is disabled.\n"));
361 int quote_char
= '\0';
364 completion_result result
= complete (arg
, &word
, "e_char
);
366 if (result
.number_matches
!= 0)
368 std::string
arg_prefix (arg
, word
- arg
);
370 if (result
.number_matches
== 1)
371 printf_unfiltered ("%s%s\n", arg_prefix
.c_str (), result
.match_list
[0]);
374 result
.sort_match_list ();
376 for (size_t i
= 0; i
< result
.number_matches
; i
++)
378 printf_unfiltered ("%s%s",
380 result
.match_list
[i
+ 1]);
382 printf_unfiltered ("%c", quote_char
);
383 printf_unfiltered ("\n");
387 if (result
.number_matches
== max_completions
)
389 /* ARG_PREFIX and WORD are included in the output so that emacs
390 will include the message in the output. */
391 printf_unfiltered (_("%s%s %s\n"),
392 arg_prefix
.c_str (), word
,
393 get_max_completions_reached_message ());
399 is_complete_command (struct cmd_list_element
*c
)
401 return cmd_cfunc_eq (c
, complete_command
);
405 show_version (const char *args
, int from_tty
)
407 print_gdb_version (gdb_stdout
, true);
408 printf_filtered ("\n");
412 show_configuration (const char *args
, int from_tty
)
414 print_gdb_configuration (gdb_stdout
);
417 /* Handle the quit command. */
420 quit_command (const char *args
, int from_tty
)
424 /* An optional expression may be used to cause gdb to terminate with
425 the value of that expression. */
428 struct value
*val
= parse_and_eval (args
);
430 exit_code
= (int) value_as_long (val
);
433 if (!quit_confirm ())
434 error (_("Not confirmed."));
436 query_if_trace_running (from_tty
);
438 quit_force (args
? &exit_code
: NULL
, from_tty
);
442 pwd_command (const char *args
, int from_tty
)
445 error (_("The \"pwd\" command does not take an argument: %s"), args
);
447 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
450 error (_("Error finding name of working directory: %s"),
451 safe_strerror (errno
));
453 if (strcmp (cwd
.get (), current_directory
) != 0)
454 printf_unfiltered (_("Working directory %ps\n (canonically %ps).\n"),
455 styled_string (file_name_style
.style (),
457 styled_string (file_name_style
.style (), cwd
.get ()));
459 printf_unfiltered (_("Working directory %ps.\n"),
460 styled_string (file_name_style
.style (),
465 cd_command (const char *dir
, int from_tty
)
468 /* Found something other than leading repetitions of "/..". */
472 /* If the new directory is absolute, repeat is a no-op; if relative,
473 repeat might be useful but is more likely to be a mistake. */
476 gdb::unique_xmalloc_ptr
<char> dir_holder
477 (tilde_expand (dir
!= NULL
? dir
: "~"));
478 dir
= dir_holder
.get ();
481 perror_with_name (dir
);
483 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
484 /* There's too much mess with DOSish names like "d:", "d:.",
485 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
486 simply get the canonicalized name of the current directory. */
487 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
492 if (IS_DIR_SEPARATOR (dir
[len
- 1]))
494 /* Remove the trailing slash unless this is a root directory
495 (including a drive letter on non-Unix systems). */
496 if (!(len
== 1) /* "/" */
497 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
498 && !(len
== 3 && dir
[1] == ':') /* "d:/" */
504 dir_holder
.reset (savestring (dir
, len
));
505 if (IS_ABSOLUTE_PATH (dir_holder
.get ()))
507 xfree (current_directory
);
508 current_directory
= dir_holder
.release ();
512 if (IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1]))
513 current_directory
= concat (current_directory
, dir_holder
.get (),
516 current_directory
= concat (current_directory
, SLASH_STRING
,
517 dir_holder
.get (), (char *) NULL
);
520 /* Now simplify any occurrences of `.' and `..' in the pathname. */
523 for (p
= current_directory
; *p
;)
525 if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.'
526 && (p
[2] == 0 || IS_DIR_SEPARATOR (p
[2])))
527 memmove (p
, p
+ 2, strlen (p
+ 2) + 1);
528 else if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.' && p
[2] == '.'
529 && (p
[3] == 0 || IS_DIR_SEPARATOR (p
[3])))
533 /* Search backwards for the directory just before the "/.."
534 and obliterate it and the "/..". */
537 while (q
!= current_directory
&& !IS_DIR_SEPARATOR (q
[-1]))
540 if (q
== current_directory
)
541 /* current_directory is
542 a relative pathname ("can't happen"--leave it alone). */
546 memmove (q
- 1, p
+ 3, strlen (p
+ 3) + 1);
551 /* We are dealing with leading repetitions of "/..", for
552 example "/../..", which is the Mach super-root. */
562 forget_cached_source_info ();
565 pwd_command ((char *) 0, 1);
568 /* Show the current value of the 'script-extension' option. */
571 show_script_ext_mode (struct ui_file
*file
, int from_tty
,
572 struct cmd_list_element
*c
, const char *value
)
574 fprintf_filtered (file
,
575 _("Script filename extension recognition is \"%s\".\n"),
579 /* Try to open SCRIPT_FILE.
580 If successful, the full path name is stored in *FULL_PATHP,
581 and the stream is returned.
582 If not successful, return NULL; errno is set for the last file
585 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
586 search for it in the source search path. */
588 gdb::optional
<open_script
>
589 find_and_open_script (const char *script_file
, int search_path
)
592 openp_flags search_flags
= OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
;
593 gdb::optional
<open_script
> opened
;
595 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (script_file
));
598 search_flags
|= OPF_SEARCH_IN_PATH
;
600 /* Search for and open 'file' on the search path used for source
601 files. Put the full location in *FULL_PATHP. */
602 gdb::unique_xmalloc_ptr
<char> full_path
;
603 fd
= openp (source_path
, search_flags
,
604 file
.get (), O_RDONLY
, &full_path
);
609 FILE *result
= fdopen (fd
, FOPEN_RT
);
612 int save_errno
= errno
;
618 opened
.emplace (gdb_file_up (result
), std::move (full_path
));
623 /* Load script FILE, which has already been opened as STREAM.
624 FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
625 This is provided as FILE may have been found via the source search path.
626 An important thing to note here is that FILE may be a symlink to a file
627 with a different or non-existing suffix, and thus one cannot infer the
628 extension language from FILE_TO_OPEN. */
631 source_script_from_stream (FILE *stream
, const char *file
,
632 const char *file_to_open
)
634 if (script_ext_mode
!= script_ext_off
)
636 const struct extension_language_defn
*extlang
637 = get_ext_lang_of_file (file
);
641 if (ext_lang_present_p (extlang
))
643 script_sourcer_func
*sourcer
644 = ext_lang_script_sourcer (extlang
);
646 gdb_assert (sourcer
!= NULL
);
647 sourcer (extlang
, stream
, file_to_open
);
650 else if (script_ext_mode
== script_ext_soft
)
652 /* Assume the file is a gdb script.
653 This is handled below. */
656 throw_ext_lang_unsupported (extlang
);
660 script_from_file (stream
, file
);
663 /* Worker to perform the "source" command.
665 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
666 search for it in the source search path. */
669 source_script_with_search (const char *file
, int from_tty
, int search_path
)
672 if (file
== NULL
|| *file
== 0)
673 error (_("source command requires file name of file to source."));
675 gdb::optional
<open_script
> opened
= find_and_open_script (file
, search_path
);
678 /* The script wasn't found, or was otherwise inaccessible.
679 If the source command was invoked interactively, throw an
680 error. Otherwise (e.g. if it was invoked by a script),
681 just emit a warning, rather than cause an error. */
683 perror_with_name (file
);
686 perror_warning_with_name (file
);
691 /* The python support reopens the file, so we need to pass full_path here
692 in case the file was found on the search path. It's useful to do this
693 anyway so that error messages show the actual file used. But only do
694 this if we (may have) used search_path, as printing the full path in
695 errors for the non-search case can be more noise than signal. */
696 source_script_from_stream (opened
->stream
.get (), file
,
697 search_path
? opened
->full_path
.get () : file
);
700 /* Wrapper around source_script_with_search to export it to main.c
701 for use in loading .gdbinit scripts. */
704 source_script (const char *file
, int from_tty
)
706 source_script_with_search (file
, from_tty
, 0);
710 source_command (const char *args
, int from_tty
)
712 const char *file
= args
;
715 scoped_restore save_source_verbose
= make_scoped_restore (&source_verbose
);
717 /* -v causes the source command to run in verbose mode.
718 -s causes the file to be searched in the source search path,
719 even if the file name contains a '/'.
720 We still have to be able to handle filenames with spaces in a
721 backward compatible way, so buildargv is not appropriate. */
725 while (args
[0] != '\0')
727 /* Make sure leading white space does not break the
729 args
= skip_spaces (args
);
734 if (args
[1] == 'v' && isspace (args
[2]))
738 /* Skip passed -v. */
741 else if (args
[1] == 's' && isspace (args
[2]))
745 /* Skip passed -s. */
752 file
= skip_spaces (args
);
755 source_script_with_search (file
, from_tty
, search_path
);
760 echo_command (const char *text
, int from_tty
)
762 const char *p
= text
;
766 while ((c
= *p
++) != '\0')
770 /* \ at end of argument is used after spaces
771 so they won't be lost. */
775 c
= parse_escape (get_current_arch (), &p
);
777 printf_filtered ("%c", c
);
780 printf_filtered ("%c", c
);
783 reset_terminal_style (gdb_stdout
);
785 /* Force this output to appear now. */
787 gdb_flush (gdb_stdout
);
790 /* Sets the last launched shell command convenience variables based on
794 exit_status_set_internal_vars (int exit_status
)
796 struct internalvar
*var_code
= lookup_internalvar ("_shell_exitcode");
797 struct internalvar
*var_signal
= lookup_internalvar ("_shell_exitsignal");
799 clear_internalvar (var_code
);
800 clear_internalvar (var_signal
);
801 if (WIFEXITED (exit_status
))
802 set_internalvar_integer (var_code
, WEXITSTATUS (exit_status
));
804 else if (WIFSIGNALED (exit_status
) && WTERMSIG (exit_status
) == -1)
806 /* The -1 condition can happen on MinGW, if we don't recognize
807 the fatal exception code encoded in the exit status; see
808 gdbsupport/gdb_wait.c. We don't want to lose information in
809 the exit status in that case. Record it as a normal exit
810 with the full exit status, including the higher 0xC0000000
812 set_internalvar_integer (var_code
, exit_status
);
815 else if (WIFSIGNALED (exit_status
))
816 set_internalvar_integer (var_signal
, WTERMSIG (exit_status
));
818 warning (_("unexpected shell command exit status %d"), exit_status
);
822 shell_escape (const char *arg
, int from_tty
)
824 #if defined(CANT_FORK) || \
825 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
826 /* If ARG is NULL, they want an inferior shell, but `system' just
827 reports if the shell is available when passed a NULL arg. */
828 int rc
= system (arg
? arg
: "");
831 arg
= "inferior shell";
834 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
835 safe_strerror (errno
));
837 fprintf_unfiltered (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
839 /* Make sure to return to the directory GDB thinks it is, in case
840 the shell command we just ran changed it. */
841 chdir (current_directory
);
842 exit_status_set_internal_vars (rc
);
844 #else /* Can fork. */
847 if ((pid
= vfork ()) == 0)
849 const char *p
, *user_shell
= get_shell ();
853 /* Get the name of the shell for arg0. */
854 p
= lbasename (user_shell
);
857 execl (user_shell
, p
, (char *) 0);
859 execl (user_shell
, p
, "-c", arg
, (char *) 0);
861 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
862 safe_strerror (errno
));
867 waitpid (pid
, &status
, 0);
869 error (_("Fork failed"));
870 exit_status_set_internal_vars (status
);
871 #endif /* Can fork. */
874 /* Implementation of the "shell" command. */
877 shell_command (const char *arg
, int from_tty
)
879 shell_escape (arg
, from_tty
);
883 edit_command (const char *arg
, int from_tty
)
885 struct symtab_and_line sal
;
891 /* Pull in the current default source line if necessary. */
894 set_default_source_symtab_and_line ();
895 sal
= get_current_source_symtab_and_line ();
898 /* Bare "edit" edits file with present line. */
903 error (_("No default source file yet."));
904 sal
.line
+= get_lines_to_list () / 2;
910 /* Now should only be one argument -- decode it in SAL. */
912 event_location_up location
= string_to_event_location (&arg1
,
914 std::vector
<symtab_and_line
> sals
= decode_line_1 (location
.get (),
915 DECODE_LINE_LIST_MODE
,
924 if (sals
.size () > 1)
926 ambiguous_line_spec (sals
,
927 _("Specified line is ambiguous:\n"));
934 error (_("Junk at end of line specification."));
936 /* If line was specified by address, first print exactly which
937 line, and which file. In this case, sal.symtab == 0 means
938 address is outside of all known source files, not that user
939 failed to give a filename. */
942 struct gdbarch
*gdbarch
;
945 error (_("No source file for address %s."),
946 paddress (get_current_arch (), sal
.pc
));
948 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
949 sym
= find_pc_function (sal
.pc
);
951 printf_filtered ("%s is in %s (%s:%d).\n",
952 paddress (gdbarch
, sal
.pc
),
954 symtab_to_filename_for_display (sal
.symtab
),
957 printf_filtered ("%s is at %s:%d.\n",
958 paddress (gdbarch
, sal
.pc
),
959 symtab_to_filename_for_display (sal
.symtab
),
963 /* If what was given does not imply a symtab, it must be an
964 undebuggable symbol which means no source code. */
967 error (_("No line number known for %s."), arg
);
970 if ((editor
= getenv ("EDITOR")) == NULL
)
973 fn
= symtab_to_fullname (sal
.symtab
);
975 /* Quote the file name, in case it has whitespace or other special
977 p
= xstrprintf ("%s +%d \"%s\"", editor
, sal
.line
, fn
);
978 shell_escape (p
, from_tty
);
982 /* The options for the "pipe" command. */
987 char *delimiter
= nullptr;
995 static const gdb::option::option_def pipe_cmd_option_defs
[] = {
997 gdb::option::string_option_def
<pipe_cmd_opts
> {
999 [] (pipe_cmd_opts
*opts
) { return &opts
->delimiter
; },
1001 N_("Indicates to use the specified delimiter string to separate\n\
1002 COMMAND from SHELL_COMMAND, in alternative to |. This is useful in\n\
1003 case COMMAND contains a | character."),
1008 /* Create an option_def_group for the "pipe" command's options, with
1011 static inline gdb::option::option_def_group
1012 make_pipe_cmd_options_def_group (pipe_cmd_opts
*opts
)
1014 return {{pipe_cmd_option_defs
}, opts
};
1017 /* Implementation of the "pipe" command. */
1020 pipe_command (const char *arg
, int from_tty
)
1024 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1025 gdb::option::process_options
1026 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
1028 const char *delim
= "|";
1029 if (opts
.delimiter
!= nullptr)
1030 delim
= opts
.delimiter
;
1032 const char *command
= arg
;
1033 if (command
== nullptr)
1034 error (_("Missing COMMAND"));
1036 arg
= strstr (arg
, delim
);
1039 error (_("Missing delimiter before SHELL_COMMAND"));
1041 std::string
gdb_cmd (command
, arg
- command
);
1043 arg
+= strlen (delim
); /* Skip the delimiter. */
1045 if (gdb_cmd
.empty ())
1046 gdb_cmd
= repeat_previous ();
1048 const char *shell_command
= skip_spaces (arg
);
1049 if (*shell_command
== '\0')
1050 error (_("Missing SHELL_COMMAND"));
1052 FILE *to_shell_command
= popen (shell_command
, "w");
1054 if (to_shell_command
== nullptr)
1055 error (_("Error launching \"%s\""), shell_command
);
1059 stdio_file
pipe_file (to_shell_command
);
1061 execute_command_to_ui_file (&pipe_file
, gdb_cmd
.c_str (), from_tty
);
1065 pclose (to_shell_command
);
1069 int exit_status
= pclose (to_shell_command
);
1071 if (exit_status
< 0)
1072 error (_("shell command \"%s\" failed: %s"), shell_command
,
1073 safe_strerror (errno
));
1074 exit_status_set_internal_vars (exit_status
);
1077 /* Completer for the pipe command. */
1080 pipe_command_completer (struct cmd_list_element
*ignore
,
1081 completion_tracker
&tracker
,
1082 const char *text
, const char *word_ignored
)
1086 const char *org_text
= text
;
1087 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1088 if (gdb::option::complete_options
1089 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
))
1092 const char *delimiter
= "|";
1093 if (opts
.delimiter
!= nullptr)
1094 delimiter
= opts
.delimiter
;
1096 /* Check if we're past option values already. */
1097 if (text
> org_text
&& !isspace (text
[-1]))
1100 const char *delim
= strstr (text
, delimiter
);
1102 /* If we're still not past the delimiter, complete the gdb
1104 if (delim
== nullptr || delim
== text
)
1106 complete_nested_command_line (tracker
, text
);
1110 /* We're past the delimiter. What follows is a shell command, which
1111 we don't know how to complete. */
1115 list_command (const char *arg
, int from_tty
)
1122 int linenum_beg
= 0;
1125 /* Pull in the current default source line if necessary. */
1126 if (arg
== NULL
|| ((arg
[0] == '+' || arg
[0] == '-') && arg
[1] == '\0'))
1128 set_default_source_symtab_and_line ();
1129 symtab_and_line cursal
= get_current_source_symtab_and_line ();
1131 /* If this is the first "list" since we've set the current
1132 source line, center the listing around that line. */
1133 if (get_first_line_listed () == 0)
1137 first
= std::max (cursal
.line
- get_lines_to_list () / 2, 1);
1139 /* A small special case --- if listing backwards, and we
1140 should list only one line, list the preceding line,
1141 instead of the exact line we've just shown after e.g.,
1142 stopping for a breakpoint. */
1143 if (arg
!= NULL
&& arg
[0] == '-'
1144 && get_lines_to_list () == 1 && first
> 1)
1147 print_source_lines (cursal
.symtab
, source_lines_range (first
), 0);
1150 /* "l" or "l +" lists next ten lines. */
1151 else if (arg
== NULL
|| arg
[0] == '+')
1152 print_source_lines (cursal
.symtab
,
1153 source_lines_range (cursal
.line
), 0);
1155 /* "l -" lists previous ten lines, the ones before the ten just
1157 else if (arg
[0] == '-')
1159 if (get_first_line_listed () == 1)
1160 error (_("Already at the start of %s."),
1161 symtab_to_filename_for_display (cursal
.symtab
));
1162 source_lines_range
range (get_first_line_listed (),
1163 source_lines_range::BACKWARD
);
1164 print_source_lines (cursal
.symtab
, range
, 0);
1170 /* Now if there is only one argument, decode it in SAL
1172 If there are two arguments, decode them in SAL and SAL_END
1173 and clear NO_END; however, if one of the arguments is blank,
1174 set DUMMY_BEG or DUMMY_END to record that fact. */
1176 if (!have_full_symbols () && !have_partial_symbols ())
1177 error (_("No symbol table is loaded. Use the \"file\" command."));
1179 std::vector
<symtab_and_line
> sals
;
1180 symtab_and_line sal
, sal_end
;
1187 event_location_up location
= string_to_event_location (&arg1
,
1189 sals
= decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1201 /* Record whether the BEG arg is all digits. */
1203 for (p
= arg
; p
!= arg1
&& *p
>= '0' && *p
<= '9'; p
++);
1204 linenum_beg
= (p
== arg1
);
1206 /* Save the range of the first argument, in case we need to let the
1207 user know it was ambiguous. */
1208 const char *beg
= arg
;
1209 size_t beg_len
= arg1
- beg
;
1211 while (*arg1
== ' ' || *arg1
== '\t')
1216 if (sals
.size () > 1)
1218 ambiguous_line_spec (sals
,
1219 _("Specified first line '%.*s' is ambiguous:\n"),
1220 (int) beg_len
, beg
);
1224 while (*arg1
== ' ' || *arg1
== '\t')
1230 /* Save the last argument, in case we need to let the user
1231 know it was ambiguous. */
1232 const char *end_arg
= arg1
;
1234 event_location_up location
1235 = string_to_event_location (&arg1
, current_language
);
1237 std::vector
<symtab_and_line
> sals_end
1239 ? decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1241 : decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1242 NULL
, sal
.symtab
, sal
.line
));
1244 filter_sals (sals_end
);
1245 if (sals_end
.empty ())
1247 if (sals_end
.size () > 1)
1249 ambiguous_line_spec (sals_end
,
1250 _("Specified last line '%s' is ambiguous:\n"),
1254 sal_end
= sals_end
[0];
1259 error (_("Junk at end of line specification."));
1261 if (!no_end
&& !dummy_beg
&& !dummy_end
1262 && sal
.symtab
!= sal_end
.symtab
)
1263 error (_("Specified first and last lines are in different files."));
1264 if (dummy_beg
&& dummy_end
)
1265 error (_("Two empty args do not say what lines to list."));
1267 /* If line was specified by address,
1268 first print exactly which line, and which file.
1270 In this case, sal.symtab == 0 means address is outside of all
1271 known source files, not that user failed to give a filename. */
1274 struct gdbarch
*gdbarch
;
1276 if (sal
.symtab
== 0)
1277 error (_("No source file for address %s."),
1278 paddress (get_current_arch (), sal
.pc
));
1280 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
1281 sym
= find_pc_function (sal
.pc
);
1283 printf_filtered ("%s is in %s (%s:%d).\n",
1284 paddress (gdbarch
, sal
.pc
),
1286 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1288 printf_filtered ("%s is at %s:%d.\n",
1289 paddress (gdbarch
, sal
.pc
),
1290 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1293 /* If line was not specified by just a line number, and it does not
1294 imply a symtab, it must be an undebuggable symbol which means no
1297 if (!linenum_beg
&& sal
.symtab
== 0)
1298 error (_("No line number known for %s."), arg
);
1300 /* If this command is repeated with RET,
1301 turn it into the no-arg variant. */
1304 set_repeat_arguments ("");
1306 if (dummy_beg
&& sal_end
.symtab
== 0)
1307 error (_("No default source file yet. Do \"help list\"."));
1310 source_lines_range
range (sal_end
.line
+ 1,
1311 source_lines_range::BACKWARD
);
1312 print_source_lines (sal_end
.symtab
, range
, 0);
1314 else if (sal
.symtab
== 0)
1315 error (_("No default source file yet. Do \"help list\"."));
1318 for (int i
= 0; i
< sals
.size (); i
++)
1321 int first_line
= sal
.line
- get_lines_to_list () / 2;
1324 if (sals
.size () > 1)
1325 print_sal_location (sal
);
1326 print_source_lines (sal
.symtab
, source_lines_range (first_line
), 0);
1330 print_source_lines (sal
.symtab
, source_lines_range (sal
.line
), 0);
1332 print_source_lines (sal
.symtab
,
1333 source_lines_range (sal
.line
, (sal_end
.line
+ 1)),
1337 /* Subroutine of disassemble_command to simplify it.
1338 Perform the disassembly.
1339 NAME is the name of the function if known, or NULL.
1340 [LOW,HIGH) are the range of addresses to disassemble.
1341 BLOCK is the block to disassemble; it needs to be provided
1342 when non-contiguous blocks are disassembled; otherwise
1344 MIXED is non-zero to print source with the assembler. */
1347 print_disassembly (struct gdbarch
*gdbarch
, const char *name
,
1348 CORE_ADDR low
, CORE_ADDR high
,
1349 const struct block
*block
,
1350 gdb_disassembly_flags flags
)
1353 if (tui_is_window_visible (DISASSEM_WIN
))
1354 tui_show_assembly (gdbarch
, low
);
1358 printf_filtered ("Dump of assembler code ");
1360 printf_filtered ("for function %s:\n", name
);
1361 if (block
== nullptr || BLOCK_CONTIGUOUS_P (block
))
1364 printf_filtered ("from %s to %s:\n",
1365 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
1367 /* Dump the specified range. */
1368 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1, low
, high
);
1372 for (int i
= 0; i
< BLOCK_NRANGES (block
); i
++)
1374 CORE_ADDR range_low
= BLOCK_RANGE_START (block
, i
);
1375 CORE_ADDR range_high
= BLOCK_RANGE_END (block
, i
);
1376 printf_filtered (_("Address range %s to %s:\n"),
1377 paddress (gdbarch
, range_low
),
1378 paddress (gdbarch
, range_high
));
1379 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1,
1380 range_low
, range_high
);
1383 printf_filtered ("End of assembler dump.\n");
1387 /* Subroutine of disassemble_command to simplify it.
1388 Print a disassembly of the current function according to FLAGS. */
1391 disassemble_current_function (gdb_disassembly_flags flags
)
1393 struct frame_info
*frame
;
1394 struct gdbarch
*gdbarch
;
1395 CORE_ADDR low
, high
, pc
;
1397 const struct block
*block
;
1399 frame
= get_selected_frame (_("No frame selected."));
1400 gdbarch
= get_frame_arch (frame
);
1401 pc
= get_frame_address_in_block (frame
);
1402 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1403 error (_("No function contains program counter for selected frame."));
1405 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1408 /* FIXME: cagney/2004-02-07: This should be an observer. */
1409 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1411 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1413 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1416 /* Dump a specified section of assembly code.
1420 - dump the assembly code for the function of the current pc
1421 disassemble [/mrs] addr
1422 - dump the assembly code for the function at ADDR
1423 disassemble [/mrs] low,high
1424 disassemble [/mrs] low,+length
1425 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1427 A /m modifier will include source code with the assembly in a
1428 "source centric" view. This view lists only the file of the first insn,
1429 even if other source files are involved (e.g., inlined functions), and
1430 the output is in source order, even with optimized code. This view is
1431 considered deprecated as it hasn't been useful in practice.
1433 A /r modifier will include raw instructions in hex with the assembly.
1435 A /s modifier will include source code with the assembly, like /m, with
1436 two important differences:
1437 1) The output is still in pc address order.
1438 2) File names and contents for all relevant source files are displayed. */
1441 disassemble_command (const char *arg
, int from_tty
)
1443 struct gdbarch
*gdbarch
= get_current_arch ();
1444 CORE_ADDR low
, high
;
1447 gdb_disassembly_flags flags
;
1449 const struct block
*block
= nullptr;
1460 error (_("Missing modifier."));
1462 while (*p
&& ! isspace (*p
))
1467 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1470 flags
|= DISASSEMBLY_RAW_INSN
;
1473 flags
|= DISASSEMBLY_SOURCE
;
1476 error (_("Invalid disassembly modifier."));
1480 p
= skip_spaces (p
);
1483 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1484 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1485 error (_("Cannot specify both /m and /s."));
1489 flags
|= DISASSEMBLY_OMIT_FNAME
;
1490 disassemble_current_function (flags
);
1494 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1500 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1501 error (_("No function contains specified address."));
1503 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1506 /* FIXME: cagney/2004-02-07: This should be an observer. */
1507 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1509 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1510 flags
|= DISASSEMBLY_OMIT_FNAME
;
1514 /* Two arguments. */
1517 p
= skip_spaces (p
);
1523 high
= parse_and_eval_address (p
);
1528 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1532 make_command (const char *arg
, int from_tty
)
1535 shell_escape ("make", from_tty
);
1538 std::string cmd
= std::string ("make ") + arg
;
1540 shell_escape (cmd
.c_str (), from_tty
);
1545 show_user (const char *args
, int from_tty
)
1547 struct cmd_list_element
*c
;
1551 const char *comname
= args
;
1553 c
= lookup_cmd (&comname
, cmdlist
, "", 0, 1);
1554 if (!cli_user_command_p (c
))
1555 error (_("Not a user command."));
1556 show_user_1 (c
, "", args
, gdb_stdout
);
1560 for (c
= cmdlist
; c
; c
= c
->next
)
1562 if (cli_user_command_p (c
) || c
->prefixlist
!= NULL
)
1563 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1568 /* Search through names of commands and documentations for a certain
1569 regular expression. */
1572 apropos_command (const char *arg
, int from_tty
)
1574 bool verbose
= arg
&& check_for_argument (&arg
, "-v", 2);
1576 if (arg
== NULL
|| *arg
== '\0')
1577 error (_("REGEXP string is empty"));
1579 compiled_regex
pattern (arg
, REG_ICASE
,
1580 _("Error in regular expression"));
1582 apropos_cmd (gdb_stdout
, cmdlist
, verbose
, pattern
, "");
1585 /* Subroutine of alias_command to simplify it.
1586 Return the first N elements of ARGV flattened back to a string
1587 with a space separating each element.
1588 ARGV may not be NULL.
1589 This does not take care of quoting elements in case they contain spaces
1593 argv_to_string (char **argv
, int n
)
1598 gdb_assert (argv
!= NULL
);
1599 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1601 for (i
= 0; i
< n
; ++i
)
1611 /* Subroutine of alias_command to simplify it.
1612 Return true if COMMAND exists, unambiguously. Otherwise false. */
1615 valid_command_p (const char *command
)
1617 struct cmd_list_element
*c
;
1619 c
= lookup_cmd_1 (& command
, cmdlist
, NULL
, 1);
1621 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1624 /* This is the slightly tricky part.
1625 lookup_cmd_1 will return a pointer to the last part of COMMAND
1626 to match, leaving COMMAND pointing at the remainder. */
1627 while (*command
== ' ' || *command
== '\t')
1629 return *command
== '\0';
1632 /* Called when "alias" was incorrectly used. */
1635 alias_usage_error (void)
1637 error (_("Usage: alias [-a] [--] ALIAS = COMMAND"));
1640 /* Make an alias of an existing command. */
1643 alias_command (const char *args
, int from_tty
)
1645 int i
, alias_argc
, command_argc
;
1646 int abbrev_flag
= 0;
1648 const char *alias
, *command
;
1650 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1651 alias_usage_error ();
1653 equals
= strchr (args
, '=');
1654 std::string
args2 (args
, equals
- args
);
1656 gdb_argv
built_alias_argv (args2
.c_str ());
1657 gdb_argv
command_argv (equals
+ 1);
1659 char **alias_argv
= built_alias_argv
.get ();
1660 while (alias_argv
[0] != NULL
)
1662 if (strcmp (alias_argv
[0], "-a") == 0)
1667 else if (strcmp (alias_argv
[0], "--") == 0)
1676 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1677 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1678 alias_usage_error ();
1680 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1682 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1685 error (_("Invalid command name: %s"), alias_argv
[i
]);
1687 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1691 alias_argc
= countargv (alias_argv
);
1692 command_argc
= command_argv
.count ();
1694 /* COMMAND must exist.
1695 Reconstruct the command to remove any extraneous spaces,
1696 for better error messages. */
1697 std::string
command_string (argv_to_string (command_argv
.get (),
1699 command
= command_string
.c_str ();
1700 if (! valid_command_p (command
))
1701 error (_("Invalid command to alias to: %s"), command
);
1703 /* ALIAS must not exist. */
1704 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1705 alias
= alias_string
.c_str ();
1706 if (valid_command_p (alias
))
1707 error (_("Alias already exists: %s"), alias
);
1709 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1710 Example: alias spe = set print elements
1712 Otherwise ALIAS and COMMAND must have the same number of words,
1713 and every word except the last must identify the same prefix command;
1714 and the last word of ALIAS is made an alias of the last word of COMMAND.
1715 Example: alias set print elms = set pr elem
1716 Note that unambiguous abbreviations are allowed. */
1718 if (alias_argc
== 1)
1720 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1721 add_com_alias (xstrdup (alias_argv
[0]), command
, class_alias
,
1726 const char *alias_prefix
, *command_prefix
;
1727 struct cmd_list_element
*c_alias
, *c_command
;
1729 if (alias_argc
!= command_argc
)
1730 error (_("Mismatched command length between ALIAS and COMMAND."));
1732 /* Create copies of ALIAS and COMMAND without the last word,
1733 and use that to verify the leading elements give the same
1735 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1737 std::string
command_prefix_string (argv_to_string (command_argv
.get (),
1739 alias_prefix
= alias_prefix_string
.c_str ();
1740 command_prefix
= command_prefix_string
.c_str ();
1742 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, 1);
1743 /* We've already tried to look up COMMAND. */
1744 gdb_assert (c_command
!= NULL
1745 && c_command
!= (struct cmd_list_element
*) -1);
1746 gdb_assert (c_command
->prefixlist
!= NULL
);
1747 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, 1);
1748 if (c_alias
!= c_command
)
1749 error (_("ALIAS and COMMAND prefixes do not match."));
1751 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1752 add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1753 command_argv
[command_argc
- 1],
1754 class_alias
, abbrev_flag
, c_command
->prefixlist
);
1758 /* Print the file / line number / symbol name of the location
1759 specified by SAL. */
1762 print_sal_location (const symtab_and_line
&sal
)
1764 scoped_restore_current_program_space restore_pspace
;
1765 set_current_program_space (sal
.pspace
);
1767 const char *sym_name
= NULL
;
1768 if (sal
.symbol
!= NULL
)
1769 sym_name
= sal
.symbol
->print_name ();
1770 printf_filtered (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
1771 symtab_to_filename_for_display (sal
.symtab
),
1772 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
1775 /* Print a list of files and line numbers which a user may choose from
1776 in order to list a function which was specified ambiguously (as
1777 with `list classname::overloadedfuncname', for example). The SALS
1778 array provides the filenames and line numbers. FORMAT is a
1779 printf-style format string used to tell the user what was
1783 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
1784 const char *format
, ...)
1787 va_start (ap
, format
);
1788 vprintf_filtered (format
, ap
);
1791 for (const auto &sal
: sals
)
1792 print_sal_location (sal
);
1795 /* Comparison function for filter_sals. Returns a qsort-style
1799 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1801 const char *dira
= SYMTAB_DIRNAME (sala
.symtab
);
1802 const char *dirb
= SYMTAB_DIRNAME (salb
.symtab
);
1810 else if (dirb
== NULL
)
1817 r
= filename_cmp (dira
, dirb
);
1822 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
1826 if (sala
.line
< salb
.line
)
1828 return sala
.line
== salb
.line
? 0 : 1;
1831 /* Remove any SALs that do not match the current program space, or
1832 which appear to be "file:line" duplicates. */
1835 filter_sals (std::vector
<symtab_and_line
> &sals
)
1837 /* Remove SALs that do not match. */
1838 auto from
= std::remove_if (sals
.begin (), sals
.end (),
1839 [&] (const symtab_and_line
&sal
)
1840 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
1843 std::sort (sals
.begin (), from
,
1844 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1845 { return cmp_symtabs (sala
, salb
) < 0; });
1847 from
= std::unique (sals
.begin (), from
,
1848 [&] (const symtab_and_line
&sala
,
1849 const symtab_and_line
&salb
)
1850 { return cmp_symtabs (sala
, salb
) == 0; });
1852 sals
.erase (from
, sals
.end ());
1856 set_debug (const char *arg
, int from_tty
)
1858 printf_unfiltered (_("\"set debug\" must be followed by "
1859 "the name of a debug subcommand.\n"));
1860 help_list (setdebuglist
, "set debug ", all_commands
, gdb_stdout
);
1864 show_debug (const char *args
, int from_tty
)
1866 cmd_show_list (showdebuglist
, from_tty
, "");
1870 init_cmd_lists (void)
1872 max_user_call_depth
= 1024;
1876 show_info_verbose (struct ui_file
*file
, int from_tty
,
1877 struct cmd_list_element
*c
,
1881 fprintf_filtered (file
,
1882 _("Verbose printing of informational messages is %s.\n"),
1885 fprintf_filtered (file
, _("Verbosity is %s.\n"), value
);
1889 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
1890 struct cmd_list_element
*c
, const char *value
)
1892 fprintf_filtered (file
, _("History expansion on command input is %s.\n"),
1897 show_remote_debug (struct ui_file
*file
, int from_tty
,
1898 struct cmd_list_element
*c
, const char *value
)
1900 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
1905 show_remote_timeout (struct ui_file
*file
, int from_tty
,
1906 struct cmd_list_element
*c
, const char *value
)
1908 fprintf_filtered (file
,
1909 _("Timeout limit to wait for target to respond is %s.\n"),
1914 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
1915 struct cmd_list_element
*c
, const char *value
)
1917 fprintf_filtered (file
,
1918 _("The max call depth for user-defined commands is %s.\n"),
1922 /* Returns the cmd_list_element in SHOWLIST corresponding to the first
1923 argument of ARGV, which must contain one single value.
1924 Throws an error if no value provided, or value not correct.
1925 FNNAME is used in the error message. */
1927 static cmd_list_element
*
1928 setting_cmd (const char *fnname
, struct cmd_list_element
*showlist
,
1929 int argc
, struct value
**argv
)
1932 error (_("You must provide an argument to %s"), fnname
);
1934 error (_("You can only provide one argument to %s"), fnname
);
1936 struct type
*type0
= check_typedef (value_type (argv
[0]));
1938 if (TYPE_CODE (type0
) != TYPE_CODE_ARRAY
1939 && TYPE_CODE (type0
) != TYPE_CODE_STRING
)
1940 error (_("First argument of %s must be a string."), fnname
);
1942 const char *a0
= (const char *) value_contents (argv
[0]);
1943 cmd_list_element
*cmd
= lookup_cmd (&a0
, showlist
, "", -1, 0);
1945 if (cmd
== nullptr || cmd_type (cmd
) != show_cmd
)
1946 error (_("First argument of %s must be a "
1947 "valid setting of the 'show' command."), fnname
);
1952 /* Builds a value from the show CMD. */
1954 static struct value
*
1955 value_from_setting (const cmd_list_element
*cmd
, struct gdbarch
*gdbarch
)
1957 switch (cmd
->var_type
)
1960 if (*(int *) cmd
->var
== INT_MAX
)
1961 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1964 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1967 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1970 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1971 *(bool *) cmd
->var
? 1 : 0);
1972 case var_zuinteger_unlimited
:
1973 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1975 case var_auto_boolean
:
1979 switch (*(enum auto_boolean
*) cmd
->var
)
1981 case AUTO_BOOLEAN_TRUE
:
1984 case AUTO_BOOLEAN_FALSE
:
1987 case AUTO_BOOLEAN_AUTO
:
1991 gdb_assert_not_reached ("invalid var_auto_boolean");
1993 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1997 if (*(unsigned int *) cmd
->var
== UINT_MAX
)
1998 return value_from_ulongest
1999 (builtin_type (gdbarch
)->builtin_unsigned_int
, 0);
2001 return value_from_ulongest
2002 (builtin_type (gdbarch
)->builtin_unsigned_int
,
2003 *(unsigned int *) cmd
->var
);
2005 return value_from_ulongest (builtin_type (gdbarch
)->builtin_unsigned_int
,
2006 *(unsigned int *) cmd
->var
);
2008 case var_string_noescape
:
2009 case var_optional_filename
:
2012 if (*(char **) cmd
->var
)
2013 return value_cstring (*(char **) cmd
->var
, strlen (*(char **) cmd
->var
),
2014 builtin_type (gdbarch
)->builtin_char
);
2016 return value_cstring ("", 1,
2017 builtin_type (gdbarch
)->builtin_char
);
2019 gdb_assert_not_reached ("bad var_type");
2023 /* Implementation of the convenience function $_gdb_setting. */
2025 static struct value
*
2026 gdb_setting_internal_fn (struct gdbarch
*gdbarch
,
2027 const struct language_defn
*language
,
2028 void *cookie
, int argc
, struct value
**argv
)
2030 return value_from_setting (setting_cmd ("$_gdb_setting", showlist
,
2035 /* Implementation of the convenience function $_gdb_maint_setting. */
2037 static struct value
*
2038 gdb_maint_setting_internal_fn (struct gdbarch
*gdbarch
,
2039 const struct language_defn
*language
,
2040 void *cookie
, int argc
, struct value
**argv
)
2042 return value_from_setting (setting_cmd ("$_gdb_maint_setting",
2043 maintenance_show_cmdlist
,
2048 /* Builds a string value from the show CMD. */
2050 static struct value
*
2051 str_value_from_setting (const cmd_list_element
*cmd
, struct gdbarch
*gdbarch
)
2053 switch (cmd
->var_type
)
2058 case var_zuinteger_unlimited
:
2059 case var_auto_boolean
:
2063 std::string cmd_val
= get_setshow_command_value_string (cmd
);
2065 return value_cstring (cmd_val
.c_str (), cmd_val
.size (),
2066 builtin_type (gdbarch
)->builtin_char
);
2070 case var_string_noescape
:
2071 case var_optional_filename
:
2074 /* For these cases, we do not use get_setshow_command_value_string,
2075 as this function handle some characters specially, e.g. by
2076 escaping quotes. So, we directly use the cmd->var string value,
2077 similarly to the value_from_setting code for these cases. */
2078 if (*(char **) cmd
->var
)
2079 return value_cstring (*(char **) cmd
->var
, strlen (*(char **) cmd
->var
),
2080 builtin_type (gdbarch
)->builtin_char
);
2082 return value_cstring ("", 1,
2083 builtin_type (gdbarch
)->builtin_char
);
2086 gdb_assert_not_reached ("bad var_type");
2090 /* Implementation of the convenience function $_gdb_setting_str. */
2092 static struct value
*
2093 gdb_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2094 const struct language_defn
*language
,
2095 void *cookie
, int argc
, struct value
**argv
)
2097 return str_value_from_setting (setting_cmd ("$_gdb_setting_str",
2098 showlist
, argc
, argv
),
2103 /* Implementation of the convenience function $_gdb_maint_setting_str. */
2105 static struct value
*
2106 gdb_maint_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2107 const struct language_defn
*language
,
2108 void *cookie
, int argc
, struct value
**argv
)
2110 return str_value_from_setting (setting_cmd ("$_gdb_maint_setting_str",
2111 maintenance_show_cmdlist
,
2116 void _initialize_cli_cmds ();
2118 _initialize_cli_cmds ()
2120 struct cmd_list_element
*c
;
2122 /* Define the classes of commands.
2123 They will appear in the help list in alphabetical order. */
2125 add_cmd ("internals", class_maintenance
, _("\
2126 Maintenance commands.\n\
2127 Some gdb commands are provided just for use by gdb maintainers.\n\
2128 These commands are subject to frequent change, and may not be as\n\
2129 well documented as user commands."),
2131 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
2132 add_cmd ("aliases", class_alias
,
2133 _("Aliases of other commands."), &cmdlist
);
2134 add_cmd ("user-defined", class_user
, _("\
2135 User-defined commands.\n\
2136 The commands in this class are those defined by the user.\n\
2137 Use the \"define\" command to define a command."), &cmdlist
);
2138 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
2140 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
2141 add_cmd ("files", class_files
, _("Specifying and examining files."),
2143 add_cmd ("breakpoints", class_breakpoint
,
2144 _("Making program stop at certain points."), &cmdlist
);
2145 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
2146 add_cmd ("stack", class_stack
, _("\
2147 Examining the stack.\n\
2148 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
2149 counting from zero for the innermost (currently executing) frame.\n\n\
2150 At any time gdb identifies one frame as the \"selected\" frame.\n\
2151 Variable lookups are done with respect to the selected frame.\n\
2152 When the program being debugged stops, gdb selects the innermost frame.\n\
2153 The commands below can be used to select other frames by number or address."),
2155 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
2157 /* Define general commands. */
2159 add_com ("pwd", class_files
, pwd_command
, _("\
2160 Print working directory.\n\
2161 This is used for your program as well."));
2163 c
= add_cmd ("cd", class_files
, cd_command
, _("\
2164 Set working directory to DIR for debugger.\n\
2165 The debugger's current working directory specifies where scripts and other\n\
2166 files that can be loaded by GDB are located.\n\
2167 In order to change the inferior's current working directory, the recommended\n\
2168 way is to use the \"set cwd\" command."), &cmdlist
);
2169 set_cmd_completer (c
, filename_completer
);
2171 add_com ("echo", class_support
, echo_command
, _("\
2172 Print a constant string. Give string as argument.\n\
2173 C escape sequences may be used in the argument.\n\
2174 No newline is added at the end of the argument;\n\
2175 use \"\\n\" if you want a newline to be printed.\n\
2176 Since leading and trailing whitespace are ignored in command arguments,\n\
2177 if you want to print some you must use \"\\\" before leading whitespace\n\
2178 to be printed or after trailing whitespace."));
2180 add_setshow_enum_cmd ("script-extension", class_support
,
2181 script_ext_enums
, &script_ext_mode
, _("\
2182 Set mode for script filename extension recognition."), _("\
2183 Show mode for script filename extension recognition."), _("\
2184 off == no filename extension recognition (all sourced files are GDB scripts)\n\
2185 soft == evaluate script according to filename extension, fallback to GDB script"
2187 strict == evaluate script according to filename extension, error if not supported"
2190 show_script_ext_mode
,
2191 &setlist
, &showlist
);
2193 add_com ("quit", class_support
, quit_command
, _("\
2195 Usage: quit [EXPR]\n\
2196 The optional expression EXPR, if present, is evaluated and the result\n\
2197 used as GDB's exit code. The default is zero."));
2198 c
= add_com ("help", class_support
, help_command
,
2199 _("Print list of commands."));
2200 set_cmd_completer (c
, command_completer
);
2201 add_com_alias ("q", "quit", class_support
, 1);
2202 add_com_alias ("h", "help", class_support
, 1);
2204 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
2205 Set verbosity."), _("\
2206 Show verbosity."), NULL
,
2209 &setlist
, &showlist
);
2211 add_prefix_cmd ("history", class_support
, set_history
,
2212 _("Generic command for setting command history parameters."),
2213 &sethistlist
, "set history ", 0, &setlist
);
2214 add_prefix_cmd ("history", class_support
, show_history
,
2215 _("Generic command for showing command history parameters."),
2216 &showhistlist
, "show history ", 0, &showlist
);
2218 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
2219 Set history expansion on command input."), _("\
2220 Show history expansion on command input."), _("\
2221 Without an argument, history expansion is enabled."),
2223 show_history_expansion_p
,
2224 &sethistlist
, &showhistlist
);
2226 add_prefix_cmd ("info", class_info
, info_command
, _("\
2227 Generic command for showing things about the program being debugged."),
2228 &infolist
, "info ", 0, &cmdlist
);
2229 add_com_alias ("i", "info", class_info
, 1);
2230 add_com_alias ("inf", "info", class_info
, 1);
2232 add_com ("complete", class_obscure
, complete_command
,
2233 _("List the completions for the rest of the line as a command."));
2235 add_prefix_cmd ("show", class_info
, show_command
, _("\
2236 Generic command for showing things about the debugger."),
2237 &showlist
, "show ", 0, &cmdlist
);
2238 /* Another way to get at the same thing. */
2239 add_info ("set", show_command
, _("Show all GDB settings."));
2241 c
= add_com ("with", class_vars
, with_command
, _("\
2242 Temporarily set SETTING to VALUE, run COMMAND, and restore SETTING.\n\
2243 Usage: with SETTING [VALUE] [-- COMMAND]\n\
2244 Usage: w SETTING [VALUE] [-- COMMAND]\n\
2245 With no COMMAND, repeats the last executed command.\n\
2247 SETTING is any setting you can change with the \"set\" subcommands.\n\
2249 with language pascal -- print obj\n\
2250 with print elements unlimited -- print obj\n\
2252 You can change multiple settings using nested with, and use\n\
2253 abbreviations for commands and/or values. E.g.:\n\
2254 w la p -- w p el u -- p obj"));
2255 set_cmd_completer_handle_brkchars (c
, with_command_completer
);
2256 add_com_alias ("w", "with", class_vars
, 1);
2258 add_internal_function ("_gdb_setting_str", _("\
2259 $_gdb_setting_str - returns the value of a GDB setting as a string.\n\
2260 Usage: $_gdb_setting_str (setting)\n\
2262 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2263 boolean values are \"off\", \"on\".\n\
2264 Some integer settings accept an unlimited value, returned\n\
2265 as \"unlimited\"."),
2266 gdb_setting_str_internal_fn
, NULL
);
2268 add_internal_function ("_gdb_setting", _("\
2269 $_gdb_setting - returns the value of a GDB setting.\n\
2270 Usage: $_gdb_setting (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 0 or -1 depending on the setting."),
2275 gdb_setting_internal_fn
, NULL
);
2277 add_internal_function ("_gdb_maint_setting_str", _("\
2278 $_gdb_maint_setting_str - returns the value of a GDB maintenance setting as a string.\n\
2279 Usage: $_gdb_maint_setting_str (setting)\n\
2281 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2282 boolean values are \"off\", \"on\".\n\
2283 Some integer settings accept an unlimited value, returned\n\
2284 as \"unlimited\"."),
2285 gdb_maint_setting_str_internal_fn
, NULL
);
2287 add_internal_function ("_gdb_maint_setting", _("\
2288 $_gdb_maint_setting - returns the value of a GDB maintenance setting.\n\
2289 Usage: $_gdb_maint_setting (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 0 or -1 depending on the setting."),
2294 gdb_maint_setting_internal_fn
, NULL
);
2296 add_cmd ("commands", no_set_class
, show_commands
, _("\
2297 Show the history of commands you typed.\n\
2298 You can supply a command number to start with, or a `+' to start after\n\
2299 the previous command number shown."),
2302 add_cmd ("version", no_set_class
, show_version
,
2303 _("Show what version of GDB this is."), &showlist
);
2305 add_cmd ("configuration", no_set_class
, show_configuration
,
2306 _("Show how GDB was configured at build time."), &showlist
);
2308 add_setshow_zinteger_cmd ("remote", no_class
, &remote_debug
, _("\
2309 Set debugging of remote protocol."), _("\
2310 Show debugging of remote protocol."), _("\
2311 When enabled, each packet sent or received with the remote target\n\
2315 &setdebuglist
, &showdebuglist
);
2317 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
2318 &remote_timeout
, _("\
2319 Set timeout limit to wait for target to respond."), _("\
2320 Show timeout limit to wait for target to respond."), _("\
2321 This value is used to set the time limit for gdb to wait for a response\n\
2324 show_remote_timeout
,
2325 &setlist
, &showlist
);
2327 add_prefix_cmd ("debug", no_class
, set_debug
,
2328 _("Generic command for setting gdb debugging flags."),
2329 &setdebuglist
, "set debug ", 0, &setlist
);
2331 add_prefix_cmd ("debug", no_class
, show_debug
,
2332 _("Generic command for showing gdb debugging flags."),
2333 &showdebuglist
, "show debug ", 0, &showlist
);
2335 c
= add_com ("shell", class_support
, shell_command
, _("\
2336 Execute the rest of the line as a shell command.\n\
2337 With no arguments, run an inferior shell."));
2338 set_cmd_completer (c
, filename_completer
);
2340 add_com_alias ("!", "shell", class_support
, 0);
2342 c
= add_com ("edit", class_files
, edit_command
, _("\
2343 Edit specified file or function.\n\
2344 With no argument, edits file containing most recent line listed.\n\
2345 Editing targets can be specified in these ways:\n\
2346 FILE:LINENUM, to edit at that line in that file,\n\
2347 FUNCTION, to edit at the beginning of that function,\n\
2348 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2349 *ADDRESS, to edit at the line containing that address.\n\
2350 Uses EDITOR environment variable contents as editor (or ex as default)."));
2352 c
->completer
= location_completer
;
2354 c
= add_com ("pipe", class_support
, pipe_command
, _("\
2355 Send the output of a gdb command to a shell command.\n\
2356 Usage: | [COMMAND] | SHELL_COMMAND\n\
2357 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2358 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
2359 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2361 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
2363 The -d option indicates to use the string DELIM to separate COMMAND\n\
2364 from SHELL_COMMAND, in alternative to |. This is useful in\n\
2365 case COMMAND contains a | character.\n\
2367 With no COMMAND, repeat the last executed command\n\
2368 and send its output to SHELL_COMMAND."));
2369 set_cmd_completer_handle_brkchars (c
, pipe_command_completer
);
2370 add_com_alias ("|", "pipe", class_support
, 0);
2372 add_com ("list", class_files
, list_command
, _("\
2373 List specified function or line.\n\
2374 With no argument, lists ten more lines after or around previous listing.\n\
2375 \"list -\" lists the ten lines before a previous ten-line listing.\n\
2376 One argument specifies a line, and ten lines are listed around that line.\n\
2377 Two arguments with comma between specify starting and ending lines to list.\n\
2378 Lines can be specified in these ways:\n\
2379 LINENUM, to list around that line in current file,\n\
2380 FILE:LINENUM, to list around that line in that file,\n\
2381 FUNCTION, to list around beginning of that function,\n\
2382 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2383 *ADDRESS, to list around the line containing that address.\n\
2384 With two args, if one is empty, it stands for ten lines away from\n\
2387 By default, when a single location is given, display ten lines.\n\
2388 This can be changed using \"set listsize\", and the current value\n\
2389 can be shown using \"show listsize\"."));
2391 add_com_alias ("l", "list", class_files
, 1);
2394 add_com_alias ("file", "list", class_files
, 1);
2396 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
2397 Disassemble a specified section of memory.\n\
2398 Default is the function surrounding the pc of the selected frame.\n\
2400 With a /m modifier, source lines are included (if available).\n\
2401 This view is \"source centric\": the output is in source line order,\n\
2402 regardless of any optimization that is present. Only the main source file\n\
2403 is displayed, not those of, e.g., any inlined functions.\n\
2404 This modifier hasn't proved useful in practice and is deprecated\n\
2407 With a /s modifier, source lines are included (if available).\n\
2408 This differs from /m in two important respects:\n\
2409 - the output is still in pc address order, and\n\
2410 - file names and contents for all relevant source files are displayed.\n\
2412 With a /r modifier, raw instructions in hex are included.\n\
2414 With a single argument, the function surrounding that address is dumped.\n\
2415 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
2416 in the form of \"start,end\", or \"start,+length\".\n\
2418 Note that the address is interpreted as an expression, not as a location\n\
2419 like in the \"break\" command.\n\
2420 So, for example, if you want to disassemble function bar in file foo.c\n\
2421 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
2422 set_cmd_completer (c
, location_completer
);
2424 c
= add_com ("make", class_support
, make_command
, _("\
2425 Run the ``make'' program using the rest of the line as arguments."));
2426 set_cmd_completer (c
, filename_completer
);
2427 add_cmd ("user", no_class
, show_user
, _("\
2428 Show definitions of non-python/scheme user defined commands.\n\
2429 Argument is the name of the user defined command.\n\
2430 With no argument, show definitions of all user defined commands."), &showlist
);
2431 add_com ("apropos", class_support
, apropos_command
, _("\
2432 Search for commands matching a REGEXP.\n\
2433 Usage: apropos [-v] REGEXP\n\
2434 Flag -v indicates to produce a verbose output, showing full documentation\n\
2435 of the matching commands."));
2437 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
2438 &max_user_call_depth
, _("\
2439 Set the max call depth for non-python/scheme user-defined commands."), _("\
2440 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
2442 show_max_user_call_depth
,
2443 &setlist
, &showlist
);
2445 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
2446 Set tracing of GDB CLI commands."), _("\
2447 Show state of GDB CLI command tracing."), _("\
2448 When 'on', each command is displayed as it is executed."),
2451 &setlist
, &showlist
);
2453 c
= add_com ("alias", class_support
, alias_command
, _("\
2454 Define a new command that is an alias of an existing command.\n\
2455 Usage: alias [-a] [--] ALIAS = COMMAND\n\
2456 ALIAS is the name of the alias command to create.\n\
2457 COMMAND is the command being aliased to.\n\
2458 If \"-a\" is specified, the command is an abbreviation,\n\
2459 and will not appear in help command list output.\n\
2462 Make \"spe\" an alias of \"set print elements\":\n\
2463 alias spe = set print elements\n\
2464 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2465 alias -a set print elms = set print elements"));
2467 const char *source_help_text
= xstrprintf (_("\
2468 Read commands from a file named FILE.\n\
2470 Usage: source [-s] [-v] FILE\n\
2471 -s: search for the script in the source search path,\n\
2472 even if FILE contains directories.\n\
2473 -v: each command in FILE is echoed as it is executed.\n\
2475 Note that the file \"%s\" is read automatically in this way\n\
2476 when GDB is started."), GDBINIT
);
2477 c
= add_cmd ("source", class_support
, source_command
,
2478 source_help_text
, &cmdlist
);
2479 set_cmd_completer (c
, filename_completer
);