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 /* See cli/cli-cmds.h. */
197 with_command_1 (const char *set_cmd_prefix
,
198 cmd_list_element
*setlist
, const char *args
, int from_tty
)
201 error (_("Missing arguments."));
203 const char *delim
= strstr (args
, "--");
204 const char *nested_cmd
= nullptr;
207 error (_("Missing setting before '--' delimiter"));
209 if (delim
== nullptr || *skip_spaces (&delim
[2]) == '\0')
210 nested_cmd
= repeat_previous ();
212 cmd_list_element
*set_cmd
= lookup_cmd (&args
, setlist
, set_cmd_prefix
,
213 /*allow_unknown=*/ 0,
214 /*ignore_help_classes=*/ 1);
215 gdb_assert (set_cmd
!= nullptr);
217 if (set_cmd
->var
== nullptr)
218 error (_("Cannot use this setting with the \"with\" command"));
220 std::string temp_value
221 = (delim
== nullptr ? args
: std::string (args
, delim
- args
));
223 if (nested_cmd
== nullptr)
224 nested_cmd
= skip_spaces (delim
+ 2);
226 std::string org_value
= get_setshow_command_value_string (set_cmd
);
228 /* Tweak the setting to the new temporary value. */
229 do_set_command (temp_value
.c_str (), from_tty
, set_cmd
);
233 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
235 /* Execute the nested command. */
236 execute_command (nested_cmd
, from_tty
);
238 catch (const gdb_exception
&ex
)
240 /* Restore the setting and rethrow. If restoring the setting
241 throws, swallow the new exception and warn. There's nothing
242 else we can reasonably do. */
245 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
247 catch (const gdb_exception
&ex2
)
249 warning (_("Couldn't restore setting: %s"), ex2
.what ());
255 /* Restore the setting. */
256 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
259 /* See cli/cli-cmds.h. */
262 with_command_completer_1 (const char *set_cmd_prefix
,
263 completion_tracker
&tracker
,
266 tracker
.set_use_custom_word_point (true);
268 const char *delim
= strstr (text
, "--");
270 /* If we're still not past the "--" delimiter, complete the "with"
271 command as if it was a "set" command. */
274 || !isspace (delim
[-1])
275 || !(isspace (delim
[2]) || delim
[2] == '\0'))
277 std::string new_text
= std::string (set_cmd_prefix
) + text
;
278 tracker
.advance_custom_word_point_by (-(int) strlen (set_cmd_prefix
));
279 complete_nested_command_line (tracker
, new_text
.c_str ());
283 /* We're past the "--" delimiter. Complete on the sub command. */
284 const char *nested_cmd
= skip_spaces (delim
+ 2);
285 tracker
.advance_custom_word_point_by (nested_cmd
- text
);
286 complete_nested_command_line (tracker
, nested_cmd
);
289 /* The "with" command. */
292 with_command (const char *args
, int from_tty
)
294 with_command_1 ("set ", setlist
, args
, from_tty
);
297 /* "with" command completer. */
300 with_command_completer (struct cmd_list_element
*ignore
,
301 completion_tracker
&tracker
,
302 const char *text
, const char * /*word*/)
304 with_command_completer_1 ("set ", tracker
, text
);
308 /* Provide documentation on command or list given by COMMAND. FROM_TTY
312 help_command (const char *command
, int from_tty
)
314 help_cmd (command
, gdb_stdout
);
318 /* Note: The "complete" command is used by Emacs to implement completion.
319 [Is that why this function writes output with *_unfiltered?] */
322 complete_command (const char *arg
, int from_tty
)
326 if (max_completions
== 0)
328 /* Only print this for non-mi frontends. An MI frontend may not
329 be able to handle this. */
330 if (!current_uiout
->is_mi_like_p ())
332 printf_unfiltered (_("max-completions is zero,"
333 " completion is disabled.\n"));
341 int quote_char
= '\0';
344 completion_result result
= complete (arg
, &word
, "e_char
);
346 if (result
.number_matches
!= 0)
348 std::string
arg_prefix (arg
, word
- arg
);
350 if (result
.number_matches
== 1)
351 printf_unfiltered ("%s%s\n", arg_prefix
.c_str (), result
.match_list
[0]);
354 result
.sort_match_list ();
356 for (size_t i
= 0; i
< result
.number_matches
; i
++)
358 printf_unfiltered ("%s%s",
360 result
.match_list
[i
+ 1]);
362 printf_unfiltered ("%c", quote_char
);
363 printf_unfiltered ("\n");
367 if (result
.number_matches
== max_completions
)
369 /* ARG_PREFIX and WORD are included in the output so that emacs
370 will include the message in the output. */
371 printf_unfiltered (_("%s%s %s\n"),
372 arg_prefix
.c_str (), word
,
373 get_max_completions_reached_message ());
379 is_complete_command (struct cmd_list_element
*c
)
381 return cmd_cfunc_eq (c
, complete_command
);
385 show_version (const char *args
, int from_tty
)
387 print_gdb_version (gdb_stdout
, true);
388 printf_filtered ("\n");
392 show_configuration (const char *args
, int from_tty
)
394 print_gdb_configuration (gdb_stdout
);
397 /* Handle the quit command. */
400 quit_command (const char *args
, int from_tty
)
404 /* An optional expression may be used to cause gdb to terminate with
405 the value of that expression. */
408 struct value
*val
= parse_and_eval (args
);
410 exit_code
= (int) value_as_long (val
);
413 if (!quit_confirm ())
414 error (_("Not confirmed."));
416 query_if_trace_running (from_tty
);
418 quit_force (args
? &exit_code
: NULL
, from_tty
);
422 pwd_command (const char *args
, int from_tty
)
425 error (_("The \"pwd\" command does not take an argument: %s"), args
);
427 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
430 error (_("Error finding name of working directory: %s"),
431 safe_strerror (errno
));
433 if (strcmp (cwd
.get (), current_directory
) != 0)
434 printf_unfiltered (_("Working directory %ps\n (canonically %ps).\n"),
435 styled_string (file_name_style
.style (),
437 styled_string (file_name_style
.style (), cwd
.get ()));
439 printf_unfiltered (_("Working directory %ps.\n"),
440 styled_string (file_name_style
.style (),
445 cd_command (const char *dir
, int from_tty
)
448 /* Found something other than leading repetitions of "/..". */
452 /* If the new directory is absolute, repeat is a no-op; if relative,
453 repeat might be useful but is more likely to be a mistake. */
456 gdb::unique_xmalloc_ptr
<char> dir_holder
457 (tilde_expand (dir
!= NULL
? dir
: "~"));
458 dir
= dir_holder
.get ();
461 perror_with_name (dir
);
463 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
464 /* There's too much mess with DOSish names like "d:", "d:.",
465 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
466 simply get the canonicalized name of the current directory. */
467 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
472 if (IS_DIR_SEPARATOR (dir
[len
- 1]))
474 /* Remove the trailing slash unless this is a root directory
475 (including a drive letter on non-Unix systems). */
476 if (!(len
== 1) /* "/" */
477 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
478 && !(len
== 3 && dir
[1] == ':') /* "d:/" */
484 dir_holder
.reset (savestring (dir
, len
));
485 if (IS_ABSOLUTE_PATH (dir_holder
.get ()))
487 xfree (current_directory
);
488 current_directory
= dir_holder
.release ();
492 if (IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1]))
493 current_directory
= concat (current_directory
, dir_holder
.get (),
496 current_directory
= concat (current_directory
, SLASH_STRING
,
497 dir_holder
.get (), (char *) NULL
);
500 /* Now simplify any occurrences of `.' and `..' in the pathname. */
503 for (p
= current_directory
; *p
;)
505 if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.'
506 && (p
[2] == 0 || IS_DIR_SEPARATOR (p
[2])))
507 memmove (p
, p
+ 2, strlen (p
+ 2) + 1);
508 else if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.' && p
[2] == '.'
509 && (p
[3] == 0 || IS_DIR_SEPARATOR (p
[3])))
513 /* Search backwards for the directory just before the "/.."
514 and obliterate it and the "/..". */
517 while (q
!= current_directory
&& !IS_DIR_SEPARATOR (q
[-1]))
520 if (q
== current_directory
)
521 /* current_directory is
522 a relative pathname ("can't happen"--leave it alone). */
526 memmove (q
- 1, p
+ 3, strlen (p
+ 3) + 1);
531 /* We are dealing with leading repetitions of "/..", for
532 example "/../..", which is the Mach super-root. */
542 forget_cached_source_info ();
545 pwd_command ((char *) 0, 1);
548 /* Show the current value of the 'script-extension' option. */
551 show_script_ext_mode (struct ui_file
*file
, int from_tty
,
552 struct cmd_list_element
*c
, const char *value
)
554 fprintf_filtered (file
,
555 _("Script filename extension recognition is \"%s\".\n"),
559 /* Try to open SCRIPT_FILE.
560 If successful, the full path name is stored in *FULL_PATHP,
561 and the stream is returned.
562 If not successful, return NULL; errno is set for the last file
565 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
566 search for it in the source search path. */
568 gdb::optional
<open_script
>
569 find_and_open_script (const char *script_file
, int search_path
)
572 openp_flags search_flags
= OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
;
573 gdb::optional
<open_script
> opened
;
575 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (script_file
));
578 search_flags
|= OPF_SEARCH_IN_PATH
;
580 /* Search for and open 'file' on the search path used for source
581 files. Put the full location in *FULL_PATHP. */
582 gdb::unique_xmalloc_ptr
<char> full_path
;
583 fd
= openp (source_path
, search_flags
,
584 file
.get (), O_RDONLY
, &full_path
);
589 FILE *result
= fdopen (fd
, FOPEN_RT
);
592 int save_errno
= errno
;
598 opened
.emplace (gdb_file_up (result
), std::move (full_path
));
603 /* Load script FILE, which has already been opened as STREAM.
604 FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
605 This is provided as FILE may have been found via the source search path.
606 An important thing to note here is that FILE may be a symlink to a file
607 with a different or non-existing suffix, and thus one cannot infer the
608 extension language from FILE_TO_OPEN. */
611 source_script_from_stream (FILE *stream
, const char *file
,
612 const char *file_to_open
)
614 if (script_ext_mode
!= script_ext_off
)
616 const struct extension_language_defn
*extlang
617 = get_ext_lang_of_file (file
);
621 if (ext_lang_present_p (extlang
))
623 script_sourcer_func
*sourcer
624 = ext_lang_script_sourcer (extlang
);
626 gdb_assert (sourcer
!= NULL
);
627 sourcer (extlang
, stream
, file_to_open
);
630 else if (script_ext_mode
== script_ext_soft
)
632 /* Assume the file is a gdb script.
633 This is handled below. */
636 throw_ext_lang_unsupported (extlang
);
640 script_from_file (stream
, file
);
643 /* Worker to perform the "source" command.
645 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
646 search for it in the source search path. */
649 source_script_with_search (const char *file
, int from_tty
, int search_path
)
652 if (file
== NULL
|| *file
== 0)
653 error (_("source command requires file name of file to source."));
655 gdb::optional
<open_script
> opened
= find_and_open_script (file
, search_path
);
658 /* The script wasn't found, or was otherwise inaccessible.
659 If the source command was invoked interactively, throw an
660 error. Otherwise (e.g. if it was invoked by a script),
661 just emit a warning, rather than cause an error. */
663 perror_with_name (file
);
666 perror_warning_with_name (file
);
671 /* The python support reopens the file, so we need to pass full_path here
672 in case the file was found on the search path. It's useful to do this
673 anyway so that error messages show the actual file used. But only do
674 this if we (may have) used search_path, as printing the full path in
675 errors for the non-search case can be more noise than signal. */
676 source_script_from_stream (opened
->stream
.get (), file
,
677 search_path
? opened
->full_path
.get () : file
);
680 /* Wrapper around source_script_with_search to export it to main.c
681 for use in loading .gdbinit scripts. */
684 source_script (const char *file
, int from_tty
)
686 source_script_with_search (file
, from_tty
, 0);
690 source_command (const char *args
, int from_tty
)
692 const char *file
= args
;
695 scoped_restore save_source_verbose
= make_scoped_restore (&source_verbose
);
697 /* -v causes the source command to run in verbose mode.
698 -s causes the file to be searched in the source search path,
699 even if the file name contains a '/'.
700 We still have to be able to handle filenames with spaces in a
701 backward compatible way, so buildargv is not appropriate. */
705 while (args
[0] != '\0')
707 /* Make sure leading white space does not break the
709 args
= skip_spaces (args
);
714 if (args
[1] == 'v' && isspace (args
[2]))
718 /* Skip passed -v. */
721 else if (args
[1] == 's' && isspace (args
[2]))
725 /* Skip passed -s. */
732 file
= skip_spaces (args
);
735 source_script_with_search (file
, from_tty
, search_path
);
740 echo_command (const char *text
, int from_tty
)
742 const char *p
= text
;
746 while ((c
= *p
++) != '\0')
750 /* \ at end of argument is used after spaces
751 so they won't be lost. */
755 c
= parse_escape (get_current_arch (), &p
);
757 printf_filtered ("%c", c
);
760 printf_filtered ("%c", c
);
763 reset_terminal_style (gdb_stdout
);
765 /* Force this output to appear now. */
767 gdb_flush (gdb_stdout
);
770 /* Sets the last launched shell command convenience variables based on
774 exit_status_set_internal_vars (int exit_status
)
776 struct internalvar
*var_code
= lookup_internalvar ("_shell_exitcode");
777 struct internalvar
*var_signal
= lookup_internalvar ("_shell_exitsignal");
779 clear_internalvar (var_code
);
780 clear_internalvar (var_signal
);
781 if (WIFEXITED (exit_status
))
782 set_internalvar_integer (var_code
, WEXITSTATUS (exit_status
));
784 else if (WIFSIGNALED (exit_status
) && WTERMSIG (exit_status
) == -1)
786 /* The -1 condition can happen on MinGW, if we don't recognize
787 the fatal exception code encoded in the exit status; see
788 gdbsupport/gdb_wait.c. We don't want to lose information in
789 the exit status in that case. Record it as a normal exit
790 with the full exit status, including the higher 0xC0000000
792 set_internalvar_integer (var_code
, exit_status
);
795 else if (WIFSIGNALED (exit_status
))
796 set_internalvar_integer (var_signal
, WTERMSIG (exit_status
));
798 warning (_("unexpected shell command exit status %d"), exit_status
);
802 shell_escape (const char *arg
, int from_tty
)
804 #if defined(CANT_FORK) || \
805 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
806 /* If ARG is NULL, they want an inferior shell, but `system' just
807 reports if the shell is available when passed a NULL arg. */
808 int rc
= system (arg
? arg
: "");
811 arg
= "inferior shell";
814 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
815 safe_strerror (errno
));
817 fprintf_unfiltered (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
819 /* Make sure to return to the directory GDB thinks it is, in case
820 the shell command we just ran changed it. */
821 chdir (current_directory
);
822 exit_status_set_internal_vars (rc
);
824 #else /* Can fork. */
827 if ((pid
= vfork ()) == 0)
829 const char *p
, *user_shell
= get_shell ();
833 /* Get the name of the shell for arg0. */
834 p
= lbasename (user_shell
);
837 execl (user_shell
, p
, (char *) 0);
839 execl (user_shell
, p
, "-c", arg
, (char *) 0);
841 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
842 safe_strerror (errno
));
847 waitpid (pid
, &status
, 0);
849 error (_("Fork failed"));
850 exit_status_set_internal_vars (status
);
851 #endif /* Can fork. */
854 /* Implementation of the "shell" command. */
857 shell_command (const char *arg
, int from_tty
)
859 shell_escape (arg
, from_tty
);
863 edit_command (const char *arg
, int from_tty
)
865 struct symtab_and_line sal
;
871 /* Pull in the current default source line if necessary. */
874 set_default_source_symtab_and_line ();
875 sal
= get_current_source_symtab_and_line ();
878 /* Bare "edit" edits file with present line. */
883 error (_("No default source file yet."));
884 sal
.line
+= get_lines_to_list () / 2;
890 /* Now should only be one argument -- decode it in SAL. */
892 event_location_up location
= string_to_event_location (&arg1
,
894 std::vector
<symtab_and_line
> sals
= decode_line_1 (location
.get (),
895 DECODE_LINE_LIST_MODE
,
904 if (sals
.size () > 1)
906 ambiguous_line_spec (sals
,
907 _("Specified line is ambiguous:\n"));
914 error (_("Junk at end of line specification."));
916 /* If line was specified by address, first print exactly which
917 line, and which file. In this case, sal.symtab == 0 means
918 address is outside of all known source files, not that user
919 failed to give a filename. */
922 struct gdbarch
*gdbarch
;
925 error (_("No source file for address %s."),
926 paddress (get_current_arch (), sal
.pc
));
928 gdbarch
= SYMTAB_OBJFILE (sal
.symtab
)->arch ();
929 sym
= find_pc_function (sal
.pc
);
931 printf_filtered ("%s is in %s (%s:%d).\n",
932 paddress (gdbarch
, sal
.pc
),
934 symtab_to_filename_for_display (sal
.symtab
),
937 printf_filtered ("%s is at %s:%d.\n",
938 paddress (gdbarch
, sal
.pc
),
939 symtab_to_filename_for_display (sal
.symtab
),
943 /* If what was given does not imply a symtab, it must be an
944 undebuggable symbol which means no source code. */
947 error (_("No line number known for %s."), arg
);
950 if ((editor
= getenv ("EDITOR")) == NULL
)
953 fn
= symtab_to_fullname (sal
.symtab
);
955 /* Quote the file name, in case it has whitespace or other special
957 p
= xstrprintf ("%s +%d \"%s\"", editor
, sal
.line
, fn
);
958 shell_escape (p
, from_tty
);
962 /* The options for the "pipe" command. */
967 char *delimiter
= nullptr;
975 static const gdb::option::option_def pipe_cmd_option_defs
[] = {
977 gdb::option::string_option_def
<pipe_cmd_opts
> {
979 [] (pipe_cmd_opts
*opts
) { return &opts
->delimiter
; },
981 N_("Indicates to use the specified delimiter string to separate\n\
982 COMMAND from SHELL_COMMAND, in alternative to |. This is useful in\n\
983 case COMMAND contains a | character."),
988 /* Create an option_def_group for the "pipe" command's options, with
991 static inline gdb::option::option_def_group
992 make_pipe_cmd_options_def_group (pipe_cmd_opts
*opts
)
994 return {{pipe_cmd_option_defs
}, opts
};
997 /* Implementation of the "pipe" command. */
1000 pipe_command (const char *arg
, int from_tty
)
1004 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1005 gdb::option::process_options
1006 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
1008 const char *delim
= "|";
1009 if (opts
.delimiter
!= nullptr)
1010 delim
= opts
.delimiter
;
1012 const char *command
= arg
;
1013 if (command
== nullptr)
1014 error (_("Missing COMMAND"));
1016 arg
= strstr (arg
, delim
);
1019 error (_("Missing delimiter before SHELL_COMMAND"));
1021 std::string
gdb_cmd (command
, arg
- command
);
1023 arg
+= strlen (delim
); /* Skip the delimiter. */
1025 if (gdb_cmd
.empty ())
1026 gdb_cmd
= repeat_previous ();
1028 const char *shell_command
= skip_spaces (arg
);
1029 if (*shell_command
== '\0')
1030 error (_("Missing SHELL_COMMAND"));
1032 FILE *to_shell_command
= popen (shell_command
, "w");
1034 if (to_shell_command
== nullptr)
1035 error (_("Error launching \"%s\""), shell_command
);
1039 stdio_file
pipe_file (to_shell_command
);
1041 execute_command_to_ui_file (&pipe_file
, gdb_cmd
.c_str (), from_tty
);
1045 pclose (to_shell_command
);
1049 int exit_status
= pclose (to_shell_command
);
1051 if (exit_status
< 0)
1052 error (_("shell command \"%s\" failed: %s"), shell_command
,
1053 safe_strerror (errno
));
1054 exit_status_set_internal_vars (exit_status
);
1057 /* Completer for the pipe command. */
1060 pipe_command_completer (struct cmd_list_element
*ignore
,
1061 completion_tracker
&tracker
,
1062 const char *text
, const char *word_ignored
)
1066 const char *org_text
= text
;
1067 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1068 if (gdb::option::complete_options
1069 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
))
1072 const char *delimiter
= "|";
1073 if (opts
.delimiter
!= nullptr)
1074 delimiter
= opts
.delimiter
;
1076 /* Check if we're past option values already. */
1077 if (text
> org_text
&& !isspace (text
[-1]))
1080 const char *delim
= strstr (text
, delimiter
);
1082 /* If we're still not past the delimiter, complete the gdb
1084 if (delim
== nullptr || delim
== text
)
1086 complete_nested_command_line (tracker
, text
);
1090 /* We're past the delimiter. What follows is a shell command, which
1091 we don't know how to complete. */
1095 list_command (const char *arg
, int from_tty
)
1102 int linenum_beg
= 0;
1105 /* Pull in the current default source line if necessary. */
1106 if (arg
== NULL
|| ((arg
[0] == '+' || arg
[0] == '-') && arg
[1] == '\0'))
1108 set_default_source_symtab_and_line ();
1109 symtab_and_line cursal
= get_current_source_symtab_and_line ();
1111 /* If this is the first "list" since we've set the current
1112 source line, center the listing around that line. */
1113 if (get_first_line_listed () == 0)
1117 first
= std::max (cursal
.line
- get_lines_to_list () / 2, 1);
1119 /* A small special case --- if listing backwards, and we
1120 should list only one line, list the preceding line,
1121 instead of the exact line we've just shown after e.g.,
1122 stopping for a breakpoint. */
1123 if (arg
!= NULL
&& arg
[0] == '-'
1124 && get_lines_to_list () == 1 && first
> 1)
1127 print_source_lines (cursal
.symtab
, source_lines_range (first
), 0);
1130 /* "l" or "l +" lists next ten lines. */
1131 else if (arg
== NULL
|| arg
[0] == '+')
1132 print_source_lines (cursal
.symtab
,
1133 source_lines_range (cursal
.line
), 0);
1135 /* "l -" lists previous ten lines, the ones before the ten just
1137 else if (arg
[0] == '-')
1139 if (get_first_line_listed () == 1)
1140 error (_("Already at the start of %s."),
1141 symtab_to_filename_for_display (cursal
.symtab
));
1142 source_lines_range
range (get_first_line_listed (),
1143 source_lines_range::BACKWARD
);
1144 print_source_lines (cursal
.symtab
, range
, 0);
1150 /* Now if there is only one argument, decode it in SAL
1152 If there are two arguments, decode them in SAL and SAL_END
1153 and clear NO_END; however, if one of the arguments is blank,
1154 set DUMMY_BEG or DUMMY_END to record that fact. */
1156 if (!have_full_symbols () && !have_partial_symbols ())
1157 error (_("No symbol table is loaded. Use the \"file\" command."));
1159 std::vector
<symtab_and_line
> sals
;
1160 symtab_and_line sal
, sal_end
;
1167 event_location_up location
= string_to_event_location (&arg1
,
1169 sals
= decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1181 /* Record whether the BEG arg is all digits. */
1183 for (p
= arg
; p
!= arg1
&& *p
>= '0' && *p
<= '9'; p
++);
1184 linenum_beg
= (p
== arg1
);
1186 /* Save the range of the first argument, in case we need to let the
1187 user know it was ambiguous. */
1188 const char *beg
= arg
;
1189 size_t beg_len
= arg1
- beg
;
1191 while (*arg1
== ' ' || *arg1
== '\t')
1196 if (sals
.size () > 1)
1198 ambiguous_line_spec (sals
,
1199 _("Specified first line '%.*s' is ambiguous:\n"),
1200 (int) beg_len
, beg
);
1204 while (*arg1
== ' ' || *arg1
== '\t')
1210 /* Save the last argument, in case we need to let the user
1211 know it was ambiguous. */
1212 const char *end_arg
= arg1
;
1214 event_location_up location
1215 = string_to_event_location (&arg1
, current_language
);
1217 std::vector
<symtab_and_line
> sals_end
1219 ? decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1221 : decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1222 NULL
, sal
.symtab
, sal
.line
));
1224 filter_sals (sals_end
);
1225 if (sals_end
.empty ())
1227 if (sals_end
.size () > 1)
1229 ambiguous_line_spec (sals_end
,
1230 _("Specified last line '%s' is ambiguous:\n"),
1234 sal_end
= sals_end
[0];
1239 error (_("Junk at end of line specification."));
1241 if (!no_end
&& !dummy_beg
&& !dummy_end
1242 && sal
.symtab
!= sal_end
.symtab
)
1243 error (_("Specified first and last lines are in different files."));
1244 if (dummy_beg
&& dummy_end
)
1245 error (_("Two empty args do not say what lines to list."));
1247 /* If line was specified by address,
1248 first print exactly which line, and which file.
1250 In this case, sal.symtab == 0 means address is outside of all
1251 known source files, not that user failed to give a filename. */
1254 struct gdbarch
*gdbarch
;
1256 if (sal
.symtab
== 0)
1257 error (_("No source file for address %s."),
1258 paddress (get_current_arch (), sal
.pc
));
1260 gdbarch
= SYMTAB_OBJFILE (sal
.symtab
)->arch ();
1261 sym
= find_pc_function (sal
.pc
);
1263 printf_filtered ("%s is in %s (%s:%d).\n",
1264 paddress (gdbarch
, sal
.pc
),
1266 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1268 printf_filtered ("%s is at %s:%d.\n",
1269 paddress (gdbarch
, sal
.pc
),
1270 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1273 /* If line was not specified by just a line number, and it does not
1274 imply a symtab, it must be an undebuggable symbol which means no
1277 if (!linenum_beg
&& sal
.symtab
== 0)
1278 error (_("No line number known for %s."), arg
);
1280 /* If this command is repeated with RET,
1281 turn it into the no-arg variant. */
1284 set_repeat_arguments ("");
1286 if (dummy_beg
&& sal_end
.symtab
== 0)
1287 error (_("No default source file yet. Do \"help list\"."));
1290 source_lines_range
range (sal_end
.line
+ 1,
1291 source_lines_range::BACKWARD
);
1292 print_source_lines (sal_end
.symtab
, range
, 0);
1294 else if (sal
.symtab
== 0)
1295 error (_("No default source file yet. Do \"help list\"."));
1298 for (int i
= 0; i
< sals
.size (); i
++)
1301 int first_line
= sal
.line
- get_lines_to_list () / 2;
1304 if (sals
.size () > 1)
1305 print_sal_location (sal
);
1306 print_source_lines (sal
.symtab
, source_lines_range (first_line
), 0);
1310 print_source_lines (sal
.symtab
, source_lines_range (sal
.line
), 0);
1312 print_source_lines (sal
.symtab
,
1313 source_lines_range (sal
.line
, (sal_end
.line
+ 1)),
1317 /* Subroutine of disassemble_command to simplify it.
1318 Perform the disassembly.
1319 NAME is the name of the function if known, or NULL.
1320 [LOW,HIGH) are the range of addresses to disassemble.
1321 BLOCK is the block to disassemble; it needs to be provided
1322 when non-contiguous blocks are disassembled; otherwise
1324 MIXED is non-zero to print source with the assembler. */
1327 print_disassembly (struct gdbarch
*gdbarch
, const char *name
,
1328 CORE_ADDR low
, CORE_ADDR high
,
1329 const struct block
*block
,
1330 gdb_disassembly_flags flags
)
1333 if (tui_is_window_visible (DISASSEM_WIN
))
1334 tui_show_assembly (gdbarch
, low
);
1338 printf_filtered ("Dump of assembler code ");
1340 printf_filtered ("for function %s:\n", name
);
1341 if (block
== nullptr || BLOCK_CONTIGUOUS_P (block
))
1344 printf_filtered ("from %s to %s:\n",
1345 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
1347 /* Dump the specified range. */
1348 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1, low
, high
);
1352 for (int i
= 0; i
< BLOCK_NRANGES (block
); i
++)
1354 CORE_ADDR range_low
= BLOCK_RANGE_START (block
, i
);
1355 CORE_ADDR range_high
= BLOCK_RANGE_END (block
, i
);
1356 printf_filtered (_("Address range %s to %s:\n"),
1357 paddress (gdbarch
, range_low
),
1358 paddress (gdbarch
, range_high
));
1359 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1,
1360 range_low
, range_high
);
1363 printf_filtered ("End of assembler dump.\n");
1367 /* Subroutine of disassemble_command to simplify it.
1368 Print a disassembly of the current function according to FLAGS. */
1371 disassemble_current_function (gdb_disassembly_flags flags
)
1373 struct frame_info
*frame
;
1374 struct gdbarch
*gdbarch
;
1375 CORE_ADDR low
, high
, pc
;
1377 const struct block
*block
;
1379 frame
= get_selected_frame (_("No frame selected."));
1380 gdbarch
= get_frame_arch (frame
);
1381 pc
= get_frame_address_in_block (frame
);
1382 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1383 error (_("No function contains program counter for selected frame."));
1385 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1388 /* FIXME: cagney/2004-02-07: This should be an observer. */
1389 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1391 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1393 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1396 /* Dump a specified section of assembly code.
1400 - dump the assembly code for the function of the current pc
1401 disassemble [/mrs] addr
1402 - dump the assembly code for the function at ADDR
1403 disassemble [/mrs] low,high
1404 disassemble [/mrs] low,+length
1405 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1407 A /m modifier will include source code with the assembly in a
1408 "source centric" view. This view lists only the file of the first insn,
1409 even if other source files are involved (e.g., inlined functions), and
1410 the output is in source order, even with optimized code. This view is
1411 considered deprecated as it hasn't been useful in practice.
1413 A /r modifier will include raw instructions in hex with the assembly.
1415 A /s modifier will include source code with the assembly, like /m, with
1416 two important differences:
1417 1) The output is still in pc address order.
1418 2) File names and contents for all relevant source files are displayed. */
1421 disassemble_command (const char *arg
, int from_tty
)
1423 struct gdbarch
*gdbarch
= get_current_arch ();
1424 CORE_ADDR low
, high
;
1427 gdb_disassembly_flags flags
;
1429 const struct block
*block
= nullptr;
1440 error (_("Missing modifier."));
1442 while (*p
&& ! isspace (*p
))
1447 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1450 flags
|= DISASSEMBLY_RAW_INSN
;
1453 flags
|= DISASSEMBLY_SOURCE
;
1456 error (_("Invalid disassembly modifier."));
1460 p
= skip_spaces (p
);
1463 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1464 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1465 error (_("Cannot specify both /m and /s."));
1469 flags
|= DISASSEMBLY_OMIT_FNAME
;
1470 disassemble_current_function (flags
);
1474 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1480 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1481 error (_("No function contains specified address."));
1483 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1486 /* FIXME: cagney/2004-02-07: This should be an observer. */
1487 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1489 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1490 flags
|= DISASSEMBLY_OMIT_FNAME
;
1494 /* Two arguments. */
1497 p
= skip_spaces (p
);
1503 high
= parse_and_eval_address (p
);
1508 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1512 make_command (const char *arg
, int from_tty
)
1515 shell_escape ("make", from_tty
);
1518 std::string cmd
= std::string ("make ") + arg
;
1520 shell_escape (cmd
.c_str (), from_tty
);
1525 show_user (const char *args
, int from_tty
)
1527 struct cmd_list_element
*c
;
1531 const char *comname
= args
;
1533 c
= lookup_cmd (&comname
, cmdlist
, "", 0, 1);
1534 if (!cli_user_command_p (c
))
1535 error (_("Not a user command."));
1536 show_user_1 (c
, "", args
, gdb_stdout
);
1540 for (c
= cmdlist
; c
; c
= c
->next
)
1542 if (cli_user_command_p (c
) || c
->prefixlist
!= NULL
)
1543 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1548 /* Search through names of commands and documentations for a certain
1549 regular expression. */
1552 apropos_command (const char *arg
, int from_tty
)
1554 bool verbose
= arg
&& check_for_argument (&arg
, "-v", 2);
1556 if (arg
== NULL
|| *arg
== '\0')
1557 error (_("REGEXP string is empty"));
1559 compiled_regex
pattern (arg
, REG_ICASE
,
1560 _("Error in regular expression"));
1562 apropos_cmd (gdb_stdout
, cmdlist
, verbose
, pattern
, "");
1565 /* Subroutine of alias_command to simplify it.
1566 Return the first N elements of ARGV flattened back to a string
1567 with a space separating each element.
1568 ARGV may not be NULL.
1569 This does not take care of quoting elements in case they contain spaces
1573 argv_to_string (char **argv
, int n
)
1578 gdb_assert (argv
!= NULL
);
1579 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1581 for (i
= 0; i
< n
; ++i
)
1591 /* Subroutine of alias_command to simplify it.
1592 Return true if COMMAND exists, unambiguously. Otherwise false. */
1595 valid_command_p (const char *command
)
1597 struct cmd_list_element
*c
;
1599 c
= lookup_cmd_1 (& command
, cmdlist
, NULL
, 1);
1601 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1604 /* This is the slightly tricky part.
1605 lookup_cmd_1 will return a pointer to the last part of COMMAND
1606 to match, leaving COMMAND pointing at the remainder. */
1607 while (*command
== ' ' || *command
== '\t')
1609 return *command
== '\0';
1612 /* Called when "alias" was incorrectly used. */
1615 alias_usage_error (void)
1617 error (_("Usage: alias [-a] [--] ALIAS = COMMAND"));
1620 /* Make an alias of an existing command. */
1623 alias_command (const char *args
, int from_tty
)
1625 int i
, alias_argc
, command_argc
;
1626 int abbrev_flag
= 0;
1628 const char *alias
, *command
;
1630 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1631 alias_usage_error ();
1633 equals
= strchr (args
, '=');
1634 std::string
args2 (args
, equals
- args
);
1636 gdb_argv
built_alias_argv (args2
.c_str ());
1637 gdb_argv
command_argv (equals
+ 1);
1639 char **alias_argv
= built_alias_argv
.get ();
1640 while (alias_argv
[0] != NULL
)
1642 if (strcmp (alias_argv
[0], "-a") == 0)
1647 else if (strcmp (alias_argv
[0], "--") == 0)
1656 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1657 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1658 alias_usage_error ();
1660 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1662 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1665 error (_("Invalid command name: %s"), alias_argv
[i
]);
1667 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1671 alias_argc
= countargv (alias_argv
);
1672 command_argc
= command_argv
.count ();
1674 /* COMMAND must exist.
1675 Reconstruct the command to remove any extraneous spaces,
1676 for better error messages. */
1677 std::string
command_string (argv_to_string (command_argv
.get (),
1679 command
= command_string
.c_str ();
1680 if (! valid_command_p (command
))
1681 error (_("Invalid command to alias to: %s"), command
);
1683 /* ALIAS must not exist. */
1684 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1685 alias
= alias_string
.c_str ();
1686 if (valid_command_p (alias
))
1687 error (_("Alias already exists: %s"), alias
);
1689 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1690 Example: alias spe = set print elements
1692 Otherwise ALIAS and COMMAND must have the same number of words,
1693 and every word except the last must identify the same prefix command;
1694 and the last word of ALIAS is made an alias of the last word of COMMAND.
1695 Example: alias set print elms = set pr elem
1696 Note that unambiguous abbreviations are allowed. */
1698 if (alias_argc
== 1)
1700 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1701 add_com_alias (xstrdup (alias_argv
[0]), command
, class_alias
,
1706 const char *alias_prefix
, *command_prefix
;
1707 struct cmd_list_element
*c_alias
, *c_command
;
1709 if (alias_argc
!= command_argc
)
1710 error (_("Mismatched command length between ALIAS and COMMAND."));
1712 /* Create copies of ALIAS and COMMAND without the last word,
1713 and use that to verify the leading elements give the same
1715 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1717 std::string
command_prefix_string (argv_to_string (command_argv
.get (),
1719 alias_prefix
= alias_prefix_string
.c_str ();
1720 command_prefix
= command_prefix_string
.c_str ();
1722 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, 1);
1723 /* We've already tried to look up COMMAND. */
1724 gdb_assert (c_command
!= NULL
1725 && c_command
!= (struct cmd_list_element
*) -1);
1726 gdb_assert (c_command
->prefixlist
!= NULL
);
1727 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, 1);
1728 if (c_alias
!= c_command
)
1729 error (_("ALIAS and COMMAND prefixes do not match."));
1731 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1732 add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1733 command_argv
[command_argc
- 1],
1734 class_alias
, abbrev_flag
, c_command
->prefixlist
);
1738 /* Print the file / line number / symbol name of the location
1739 specified by SAL. */
1742 print_sal_location (const symtab_and_line
&sal
)
1744 scoped_restore_current_program_space restore_pspace
;
1745 set_current_program_space (sal
.pspace
);
1747 const char *sym_name
= NULL
;
1748 if (sal
.symbol
!= NULL
)
1749 sym_name
= sal
.symbol
->print_name ();
1750 printf_filtered (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
1751 symtab_to_filename_for_display (sal
.symtab
),
1752 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
1755 /* Print a list of files and line numbers which a user may choose from
1756 in order to list a function which was specified ambiguously (as
1757 with `list classname::overloadedfuncname', for example). The SALS
1758 array provides the filenames and line numbers. FORMAT is a
1759 printf-style format string used to tell the user what was
1763 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
1764 const char *format
, ...)
1767 va_start (ap
, format
);
1768 vprintf_filtered (format
, ap
);
1771 for (const auto &sal
: sals
)
1772 print_sal_location (sal
);
1775 /* Comparison function for filter_sals. Returns a qsort-style
1779 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1781 const char *dira
= SYMTAB_DIRNAME (sala
.symtab
);
1782 const char *dirb
= SYMTAB_DIRNAME (salb
.symtab
);
1790 else if (dirb
== NULL
)
1797 r
= filename_cmp (dira
, dirb
);
1802 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
1806 if (sala
.line
< salb
.line
)
1808 return sala
.line
== salb
.line
? 0 : 1;
1811 /* Remove any SALs that do not match the current program space, or
1812 which appear to be "file:line" duplicates. */
1815 filter_sals (std::vector
<symtab_and_line
> &sals
)
1817 /* Remove SALs that do not match. */
1818 auto from
= std::remove_if (sals
.begin (), sals
.end (),
1819 [&] (const symtab_and_line
&sal
)
1820 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
1823 std::sort (sals
.begin (), from
,
1824 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1825 { return cmp_symtabs (sala
, salb
) < 0; });
1827 from
= std::unique (sals
.begin (), from
,
1828 [&] (const symtab_and_line
&sala
,
1829 const symtab_and_line
&salb
)
1830 { return cmp_symtabs (sala
, salb
) == 0; });
1832 sals
.erase (from
, sals
.end ());
1836 init_cmd_lists (void)
1838 max_user_call_depth
= 1024;
1842 show_info_verbose (struct ui_file
*file
, int from_tty
,
1843 struct cmd_list_element
*c
,
1847 fprintf_filtered (file
,
1848 _("Verbose printing of informational messages is %s.\n"),
1851 fprintf_filtered (file
, _("Verbosity is %s.\n"), value
);
1855 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
1856 struct cmd_list_element
*c
, const char *value
)
1858 fprintf_filtered (file
, _("History expansion on command input is %s.\n"),
1863 show_remote_debug (struct ui_file
*file
, int from_tty
,
1864 struct cmd_list_element
*c
, const char *value
)
1866 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
1871 show_remote_timeout (struct ui_file
*file
, int from_tty
,
1872 struct cmd_list_element
*c
, const char *value
)
1874 fprintf_filtered (file
,
1875 _("Timeout limit to wait for target to respond is %s.\n"),
1880 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
1881 struct cmd_list_element
*c
, const char *value
)
1883 fprintf_filtered (file
,
1884 _("The max call depth for user-defined commands is %s.\n"),
1888 /* Returns the cmd_list_element in SHOWLIST corresponding to the first
1889 argument of ARGV, which must contain one single value.
1890 Throws an error if no value provided, or value not correct.
1891 FNNAME is used in the error message. */
1893 static cmd_list_element
*
1894 setting_cmd (const char *fnname
, struct cmd_list_element
*showlist
,
1895 int argc
, struct value
**argv
)
1898 error (_("You must provide an argument to %s"), fnname
);
1900 error (_("You can only provide one argument to %s"), fnname
);
1902 struct type
*type0
= check_typedef (value_type (argv
[0]));
1904 if (TYPE_CODE (type0
) != TYPE_CODE_ARRAY
1905 && TYPE_CODE (type0
) != TYPE_CODE_STRING
)
1906 error (_("First argument of %s must be a string."), fnname
);
1908 const char *a0
= (const char *) value_contents (argv
[0]);
1909 cmd_list_element
*cmd
= lookup_cmd (&a0
, showlist
, "", -1, 0);
1911 if (cmd
== nullptr || cmd_type (cmd
) != show_cmd
)
1912 error (_("First argument of %s must be a "
1913 "valid setting of the 'show' command."), fnname
);
1918 /* Builds a value from the show CMD. */
1920 static struct value
*
1921 value_from_setting (const cmd_list_element
*cmd
, struct gdbarch
*gdbarch
)
1923 switch (cmd
->var_type
)
1926 if (*(int *) cmd
->var
== INT_MAX
)
1927 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1930 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1933 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1936 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1937 *(bool *) cmd
->var
? 1 : 0);
1938 case var_zuinteger_unlimited
:
1939 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1941 case var_auto_boolean
:
1945 switch (*(enum auto_boolean
*) cmd
->var
)
1947 case AUTO_BOOLEAN_TRUE
:
1950 case AUTO_BOOLEAN_FALSE
:
1953 case AUTO_BOOLEAN_AUTO
:
1957 gdb_assert_not_reached ("invalid var_auto_boolean");
1959 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1963 if (*(unsigned int *) cmd
->var
== UINT_MAX
)
1964 return value_from_ulongest
1965 (builtin_type (gdbarch
)->builtin_unsigned_int
, 0);
1967 return value_from_ulongest
1968 (builtin_type (gdbarch
)->builtin_unsigned_int
,
1969 *(unsigned int *) cmd
->var
);
1971 return value_from_ulongest (builtin_type (gdbarch
)->builtin_unsigned_int
,
1972 *(unsigned int *) cmd
->var
);
1974 case var_string_noescape
:
1975 case var_optional_filename
:
1978 if (*(char **) cmd
->var
)
1979 return value_cstring (*(char **) cmd
->var
, strlen (*(char **) cmd
->var
),
1980 builtin_type (gdbarch
)->builtin_char
);
1982 return value_cstring ("", 1,
1983 builtin_type (gdbarch
)->builtin_char
);
1985 gdb_assert_not_reached ("bad var_type");
1989 /* Implementation of the convenience function $_gdb_setting. */
1991 static struct value
*
1992 gdb_setting_internal_fn (struct gdbarch
*gdbarch
,
1993 const struct language_defn
*language
,
1994 void *cookie
, int argc
, struct value
**argv
)
1996 return value_from_setting (setting_cmd ("$_gdb_setting", showlist
,
2001 /* Implementation of the convenience function $_gdb_maint_setting. */
2003 static struct value
*
2004 gdb_maint_setting_internal_fn (struct gdbarch
*gdbarch
,
2005 const struct language_defn
*language
,
2006 void *cookie
, int argc
, struct value
**argv
)
2008 return value_from_setting (setting_cmd ("$_gdb_maint_setting",
2009 maintenance_show_cmdlist
,
2014 /* Builds a string value from the show CMD. */
2016 static struct value
*
2017 str_value_from_setting (const cmd_list_element
*cmd
, struct gdbarch
*gdbarch
)
2019 switch (cmd
->var_type
)
2024 case var_zuinteger_unlimited
:
2025 case var_auto_boolean
:
2029 std::string cmd_val
= get_setshow_command_value_string (cmd
);
2031 return value_cstring (cmd_val
.c_str (), cmd_val
.size (),
2032 builtin_type (gdbarch
)->builtin_char
);
2036 case var_string_noescape
:
2037 case var_optional_filename
:
2040 /* For these cases, we do not use get_setshow_command_value_string,
2041 as this function handle some characters specially, e.g. by
2042 escaping quotes. So, we directly use the cmd->var string value,
2043 similarly to the value_from_setting code for these cases. */
2044 if (*(char **) cmd
->var
)
2045 return value_cstring (*(char **) cmd
->var
, strlen (*(char **) cmd
->var
),
2046 builtin_type (gdbarch
)->builtin_char
);
2048 return value_cstring ("", 1,
2049 builtin_type (gdbarch
)->builtin_char
);
2052 gdb_assert_not_reached ("bad var_type");
2056 /* Implementation of the convenience function $_gdb_setting_str. */
2058 static struct value
*
2059 gdb_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2060 const struct language_defn
*language
,
2061 void *cookie
, int argc
, struct value
**argv
)
2063 return str_value_from_setting (setting_cmd ("$_gdb_setting_str",
2064 showlist
, argc
, argv
),
2069 /* Implementation of the convenience function $_gdb_maint_setting_str. */
2071 static struct value
*
2072 gdb_maint_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2073 const struct language_defn
*language
,
2074 void *cookie
, int argc
, struct value
**argv
)
2076 return str_value_from_setting (setting_cmd ("$_gdb_maint_setting_str",
2077 maintenance_show_cmdlist
,
2082 void _initialize_cli_cmds ();
2084 _initialize_cli_cmds ()
2086 struct cmd_list_element
*c
;
2088 /* Define the classes of commands.
2089 They will appear in the help list in alphabetical order. */
2091 add_cmd ("internals", class_maintenance
, _("\
2092 Maintenance commands.\n\
2093 Some gdb commands are provided just for use by gdb maintainers.\n\
2094 These commands are subject to frequent change, and may not be as\n\
2095 well documented as user commands."),
2097 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
2098 add_cmd ("aliases", class_alias
,
2099 _("Aliases of other commands."), &cmdlist
);
2100 add_cmd ("user-defined", class_user
, _("\
2101 User-defined commands.\n\
2102 The commands in this class are those defined by the user.\n\
2103 Use the \"define\" command to define a command."), &cmdlist
);
2104 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
2106 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
2107 add_cmd ("files", class_files
, _("Specifying and examining files."),
2109 add_cmd ("breakpoints", class_breakpoint
,
2110 _("Making program stop at certain points."), &cmdlist
);
2111 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
2112 add_cmd ("stack", class_stack
, _("\
2113 Examining the stack.\n\
2114 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
2115 counting from zero for the innermost (currently executing) frame.\n\n\
2116 At any time gdb identifies one frame as the \"selected\" frame.\n\
2117 Variable lookups are done with respect to the selected frame.\n\
2118 When the program being debugged stops, gdb selects the innermost frame.\n\
2119 The commands below can be used to select other frames by number or address."),
2121 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
2123 /* Define general commands. */
2125 add_com ("pwd", class_files
, pwd_command
, _("\
2126 Print working directory.\n\
2127 This is used for your program as well."));
2129 c
= add_cmd ("cd", class_files
, cd_command
, _("\
2130 Set working directory to DIR for debugger.\n\
2131 The debugger's current working directory specifies where scripts and other\n\
2132 files that can be loaded by GDB are located.\n\
2133 In order to change the inferior's current working directory, the recommended\n\
2134 way is to use the \"set cwd\" command."), &cmdlist
);
2135 set_cmd_completer (c
, filename_completer
);
2137 add_com ("echo", class_support
, echo_command
, _("\
2138 Print a constant string. Give string as argument.\n\
2139 C escape sequences may be used in the argument.\n\
2140 No newline is added at the end of the argument;\n\
2141 use \"\\n\" if you want a newline to be printed.\n\
2142 Since leading and trailing whitespace are ignored in command arguments,\n\
2143 if you want to print some you must use \"\\\" before leading whitespace\n\
2144 to be printed or after trailing whitespace."));
2146 add_setshow_enum_cmd ("script-extension", class_support
,
2147 script_ext_enums
, &script_ext_mode
, _("\
2148 Set mode for script filename extension recognition."), _("\
2149 Show mode for script filename extension recognition."), _("\
2150 off == no filename extension recognition (all sourced files are GDB scripts)\n\
2151 soft == evaluate script according to filename extension, fallback to GDB script"
2153 strict == evaluate script according to filename extension, error if not supported"
2156 show_script_ext_mode
,
2157 &setlist
, &showlist
);
2159 add_com ("quit", class_support
, quit_command
, _("\
2161 Usage: quit [EXPR]\n\
2162 The optional expression EXPR, if present, is evaluated and the result\n\
2163 used as GDB's exit code. The default is zero."));
2164 c
= add_com ("help", class_support
, help_command
,
2165 _("Print list of commands."));
2166 set_cmd_completer (c
, command_completer
);
2167 add_com_alias ("q", "quit", class_support
, 1);
2168 add_com_alias ("h", "help", class_support
, 1);
2170 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
2171 Set verbosity."), _("\
2172 Show verbosity."), NULL
,
2175 &setlist
, &showlist
);
2177 add_basic_prefix_cmd ("history", class_support
, _("\
2178 Generic command for setting command history parameters."),
2179 &sethistlist
, "set history ", 0, &setlist
);
2180 add_show_prefix_cmd ("history", class_support
, _("\
2181 Generic command for showing command history parameters."),
2182 &showhistlist
, "show history ", 0, &showlist
);
2184 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
2185 Set history expansion on command input."), _("\
2186 Show history expansion on command input."), _("\
2187 Without an argument, history expansion is enabled."),
2189 show_history_expansion_p
,
2190 &sethistlist
, &showhistlist
);
2192 add_basic_prefix_cmd ("info", class_info
, _("\
2193 Generic command for showing things about the program being debugged."),
2194 &infolist
, "info ", 0, &cmdlist
);
2195 add_com_alias ("i", "info", class_info
, 1);
2196 add_com_alias ("inf", "info", class_info
, 1);
2198 add_com ("complete", class_obscure
, complete_command
,
2199 _("List the completions for the rest of the line as a command."));
2201 add_show_prefix_cmd ("show", class_info
, _("\
2202 Generic command for showing things about the debugger."),
2203 &showlist
, "show ", 0, &cmdlist
);
2204 /* Another way to get at the same thing. */
2205 add_show_prefix_cmd ("set", class_info
, _("Show all GDB settings."),
2206 &showlist
, "info set ", 0, &infolist
);
2208 c
= add_com ("with", class_vars
, with_command
, _("\
2209 Temporarily set SETTING to VALUE, run COMMAND, and restore SETTING.\n\
2210 Usage: with SETTING [VALUE] [-- COMMAND]\n\
2211 Usage: w SETTING [VALUE] [-- COMMAND]\n\
2212 With no COMMAND, repeats the last executed command.\n\
2214 SETTING is any setting you can change with the \"set\" subcommands.\n\
2216 with language pascal -- print obj\n\
2217 with print elements unlimited -- print obj\n\
2219 You can change multiple settings using nested with, and use\n\
2220 abbreviations for commands and/or values. E.g.:\n\
2221 w la p -- w p el u -- p obj"));
2222 set_cmd_completer_handle_brkchars (c
, with_command_completer
);
2223 add_com_alias ("w", "with", class_vars
, 1);
2225 add_internal_function ("_gdb_setting_str", _("\
2226 $_gdb_setting_str - returns the value of a GDB setting as a string.\n\
2227 Usage: $_gdb_setting_str (setting)\n\
2229 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2230 boolean values are \"off\", \"on\".\n\
2231 Some integer settings accept an unlimited value, returned\n\
2232 as \"unlimited\"."),
2233 gdb_setting_str_internal_fn
, NULL
);
2235 add_internal_function ("_gdb_setting", _("\
2236 $_gdb_setting - returns the value of a GDB setting.\n\
2237 Usage: $_gdb_setting (setting)\n\
2238 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2239 boolean values are \"off\", \"on\".\n\
2240 Some integer settings accept an unlimited value, returned\n\
2241 as 0 or -1 depending on the setting."),
2242 gdb_setting_internal_fn
, NULL
);
2244 add_internal_function ("_gdb_maint_setting_str", _("\
2245 $_gdb_maint_setting_str - returns the value of a GDB maintenance setting as a string.\n\
2246 Usage: $_gdb_maint_setting_str (setting)\n\
2248 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2249 boolean values are \"off\", \"on\".\n\
2250 Some integer settings accept an unlimited value, returned\n\
2251 as \"unlimited\"."),
2252 gdb_maint_setting_str_internal_fn
, NULL
);
2254 add_internal_function ("_gdb_maint_setting", _("\
2255 $_gdb_maint_setting - returns the value of a GDB maintenance setting.\n\
2256 Usage: $_gdb_maint_setting (setting)\n\
2257 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2258 boolean values are \"off\", \"on\".\n\
2259 Some integer settings accept an unlimited value, returned\n\
2260 as 0 or -1 depending on the setting."),
2261 gdb_maint_setting_internal_fn
, NULL
);
2263 add_cmd ("commands", no_set_class
, show_commands
, _("\
2264 Show the history of commands you typed.\n\
2265 You can supply a command number to start with, or a `+' to start after\n\
2266 the previous command number shown."),
2269 add_cmd ("version", no_set_class
, show_version
,
2270 _("Show what version of GDB this is."), &showlist
);
2272 add_cmd ("configuration", no_set_class
, show_configuration
,
2273 _("Show how GDB was configured at build time."), &showlist
);
2275 add_setshow_zinteger_cmd ("remote", no_class
, &remote_debug
, _("\
2276 Set debugging of remote protocol."), _("\
2277 Show debugging of remote protocol."), _("\
2278 When enabled, each packet sent or received with the remote target\n\
2282 &setdebuglist
, &showdebuglist
);
2284 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
2285 &remote_timeout
, _("\
2286 Set timeout limit to wait for target to respond."), _("\
2287 Show timeout limit to wait for target to respond."), _("\
2288 This value is used to set the time limit for gdb to wait for a response\n\
2291 show_remote_timeout
,
2292 &setlist
, &showlist
);
2294 add_basic_prefix_cmd ("debug", no_class
,
2295 _("Generic command for setting gdb debugging flags."),
2296 &setdebuglist
, "set debug ", 0, &setlist
);
2298 add_show_prefix_cmd ("debug", no_class
,
2299 _("Generic command for showing gdb debugging flags."),
2300 &showdebuglist
, "show debug ", 0, &showlist
);
2302 c
= add_com ("shell", class_support
, shell_command
, _("\
2303 Execute the rest of the line as a shell command.\n\
2304 With no arguments, run an inferior shell."));
2305 set_cmd_completer (c
, filename_completer
);
2307 add_com_alias ("!", "shell", class_support
, 0);
2309 c
= add_com ("edit", class_files
, edit_command
, _("\
2310 Edit specified file or function.\n\
2311 With no argument, edits file containing most recent line listed.\n\
2312 Editing targets can be specified in these ways:\n\
2313 FILE:LINENUM, to edit at that line in that file,\n\
2314 FUNCTION, to edit at the beginning of that function,\n\
2315 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2316 *ADDRESS, to edit at the line containing that address.\n\
2317 Uses EDITOR environment variable contents as editor (or ex as default)."));
2319 c
->completer
= location_completer
;
2321 c
= add_com ("pipe", class_support
, pipe_command
, _("\
2322 Send the output of a gdb command to a shell command.\n\
2323 Usage: | [COMMAND] | SHELL_COMMAND\n\
2324 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2325 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
2326 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2328 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
2330 The -d option indicates to use the string DELIM to separate COMMAND\n\
2331 from SHELL_COMMAND, in alternative to |. This is useful in\n\
2332 case COMMAND contains a | character.\n\
2334 With no COMMAND, repeat the last executed command\n\
2335 and send its output to SHELL_COMMAND."));
2336 set_cmd_completer_handle_brkchars (c
, pipe_command_completer
);
2337 add_com_alias ("|", "pipe", class_support
, 0);
2339 add_com ("list", class_files
, list_command
, _("\
2340 List specified function or line.\n\
2341 With no argument, lists ten more lines after or around previous listing.\n\
2342 \"list -\" lists the ten lines before a previous ten-line listing.\n\
2343 One argument specifies a line, and ten lines are listed around that line.\n\
2344 Two arguments with comma between specify starting and ending lines to list.\n\
2345 Lines can be specified in these ways:\n\
2346 LINENUM, to list around that line in current file,\n\
2347 FILE:LINENUM, to list around that line in that file,\n\
2348 FUNCTION, to list around beginning of that function,\n\
2349 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2350 *ADDRESS, to list around the line containing that address.\n\
2351 With two args, if one is empty, it stands for ten lines away from\n\
2354 By default, when a single location is given, display ten lines.\n\
2355 This can be changed using \"set listsize\", and the current value\n\
2356 can be shown using \"show listsize\"."));
2358 add_com_alias ("l", "list", class_files
, 1);
2361 add_com_alias ("file", "list", class_files
, 1);
2363 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
2364 Disassemble a specified section of memory.\n\
2365 Default is the function surrounding the pc of the selected frame.\n\
2367 With a /m modifier, source lines are included (if available).\n\
2368 This view is \"source centric\": the output is in source line order,\n\
2369 regardless of any optimization that is present. Only the main source file\n\
2370 is displayed, not those of, e.g., any inlined functions.\n\
2371 This modifier hasn't proved useful in practice and is deprecated\n\
2374 With a /s modifier, source lines are included (if available).\n\
2375 This differs from /m in two important respects:\n\
2376 - the output is still in pc address order, and\n\
2377 - file names and contents for all relevant source files are displayed.\n\
2379 With a /r modifier, raw instructions in hex are included.\n\
2381 With a single argument, the function surrounding that address is dumped.\n\
2382 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
2383 in the form of \"start,end\", or \"start,+length\".\n\
2385 Note that the address is interpreted as an expression, not as a location\n\
2386 like in the \"break\" command.\n\
2387 So, for example, if you want to disassemble function bar in file foo.c\n\
2388 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
2389 set_cmd_completer (c
, location_completer
);
2391 c
= add_com ("make", class_support
, make_command
, _("\
2392 Run the ``make'' program using the rest of the line as arguments."));
2393 set_cmd_completer (c
, filename_completer
);
2394 add_cmd ("user", no_class
, show_user
, _("\
2395 Show definitions of non-python/scheme user defined commands.\n\
2396 Argument is the name of the user defined command.\n\
2397 With no argument, show definitions of all user defined commands."), &showlist
);
2398 add_com ("apropos", class_support
, apropos_command
, _("\
2399 Search for commands matching a REGEXP.\n\
2400 Usage: apropos [-v] REGEXP\n\
2401 Flag -v indicates to produce a verbose output, showing full documentation\n\
2402 of the matching commands."));
2404 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
2405 &max_user_call_depth
, _("\
2406 Set the max call depth for non-python/scheme user-defined commands."), _("\
2407 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
2409 show_max_user_call_depth
,
2410 &setlist
, &showlist
);
2412 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
2413 Set tracing of GDB CLI commands."), _("\
2414 Show state of GDB CLI command tracing."), _("\
2415 When 'on', each command is displayed as it is executed."),
2418 &setlist
, &showlist
);
2420 c
= add_com ("alias", class_support
, alias_command
, _("\
2421 Define a new command that is an alias of an existing command.\n\
2422 Usage: alias [-a] [--] ALIAS = COMMAND\n\
2423 ALIAS is the name of the alias command to create.\n\
2424 COMMAND is the command being aliased to.\n\
2425 If \"-a\" is specified, the command is an abbreviation,\n\
2426 and will not appear in help command list output.\n\
2429 Make \"spe\" an alias of \"set print elements\":\n\
2430 alias spe = set print elements\n\
2431 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2432 alias -a set print elms = set print elements"));
2434 const char *source_help_text
= xstrprintf (_("\
2435 Read commands from a file named FILE.\n\
2437 Usage: source [-s] [-v] FILE\n\
2438 -s: search for the script in the source search path,\n\
2439 even if FILE contains directories.\n\
2440 -v: each command in FILE is echoed as it is executed.\n\
2442 Note that the file \"%s\" is read automatically in this way\n\
2443 when GDB is started."), GDBINIT
);
2444 c
= add_cmd ("source", class_support
, source_command
,
2445 source_help_text
, &cmdlist
);
2446 set_cmd_completer (c
, filename_completer
);