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 /* This implements the "info" prefix command. Normally such commands
195 are automatically handled by add_basic_prefix_cmd, but in this case
196 a separate command is used so that it can be hooked into by
200 info_command (const char *arg
, int from_tty
)
202 help_list (infolist
, "info ", all_commands
, gdb_stdout
);
205 /* See cli/cli-cmds.h. */
208 with_command_1 (const char *set_cmd_prefix
,
209 cmd_list_element
*setlist
, const char *args
, int from_tty
)
212 error (_("Missing arguments."));
214 const char *delim
= strstr (args
, "--");
215 const char *nested_cmd
= nullptr;
218 error (_("Missing setting before '--' delimiter"));
220 if (delim
== nullptr || *skip_spaces (&delim
[2]) == '\0')
221 nested_cmd
= repeat_previous ();
223 cmd_list_element
*set_cmd
= lookup_cmd (&args
, setlist
, set_cmd_prefix
,
224 /*allow_unknown=*/ 0,
225 /*ignore_help_classes=*/ 1);
226 gdb_assert (set_cmd
!= nullptr);
228 if (set_cmd
->var
== nullptr)
229 error (_("Cannot use this setting with the \"with\" command"));
231 std::string temp_value
232 = (delim
== nullptr ? args
: std::string (args
, delim
- args
));
234 if (nested_cmd
== nullptr)
235 nested_cmd
= skip_spaces (delim
+ 2);
237 std::string org_value
= get_setshow_command_value_string (set_cmd
);
239 /* Tweak the setting to the new temporary value. */
240 do_set_command (temp_value
.c_str (), from_tty
, set_cmd
);
244 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
246 /* Execute the nested command. */
247 execute_command (nested_cmd
, from_tty
);
249 catch (const gdb_exception
&ex
)
251 /* Restore the setting and rethrow. If restoring the setting
252 throws, swallow the new exception and warn. There's nothing
253 else we can reasonably do. */
256 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
258 catch (const gdb_exception
&ex2
)
260 warning (_("Couldn't restore setting: %s"), ex2
.what ());
266 /* Restore the setting. */
267 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
270 /* See cli/cli-cmds.h. */
273 with_command_completer_1 (const char *set_cmd_prefix
,
274 completion_tracker
&tracker
,
277 tracker
.set_use_custom_word_point (true);
279 const char *delim
= strstr (text
, "--");
281 /* If we're still not past the "--" delimiter, complete the "with"
282 command as if it was a "set" command. */
285 || !isspace (delim
[-1])
286 || !(isspace (delim
[2]) || delim
[2] == '\0'))
288 std::string new_text
= std::string (set_cmd_prefix
) + text
;
289 tracker
.advance_custom_word_point_by (-(int) strlen (set_cmd_prefix
));
290 complete_nested_command_line (tracker
, new_text
.c_str ());
294 /* We're past the "--" delimiter. Complete on the sub command. */
295 const char *nested_cmd
= skip_spaces (delim
+ 2);
296 tracker
.advance_custom_word_point_by (nested_cmd
- text
);
297 complete_nested_command_line (tracker
, nested_cmd
);
300 /* The "with" command. */
303 with_command (const char *args
, int from_tty
)
305 with_command_1 ("set ", setlist
, args
, from_tty
);
308 /* "with" command completer. */
311 with_command_completer (struct cmd_list_element
*ignore
,
312 completion_tracker
&tracker
,
313 const char *text
, const char * /*word*/)
315 with_command_completer_1 ("set ", tracker
, text
);
319 /* Provide documentation on command or list given by COMMAND. FROM_TTY
323 help_command (const char *command
, int from_tty
)
325 help_cmd (command
, gdb_stdout
);
329 /* Note: The "complete" command is used by Emacs to implement completion.
330 [Is that why this function writes output with *_unfiltered?] */
333 complete_command (const char *arg
, int from_tty
)
337 if (max_completions
== 0)
339 /* Only print this for non-mi frontends. An MI frontend may not
340 be able to handle this. */
341 if (!current_uiout
->is_mi_like_p ())
343 printf_unfiltered (_("max-completions is zero,"
344 " completion is disabled.\n"));
352 int quote_char
= '\0';
355 completion_result result
= complete (arg
, &word
, "e_char
);
357 if (result
.number_matches
!= 0)
359 std::string
arg_prefix (arg
, word
- arg
);
361 if (result
.number_matches
== 1)
362 printf_unfiltered ("%s%s\n", arg_prefix
.c_str (), result
.match_list
[0]);
365 result
.sort_match_list ();
367 for (size_t i
= 0; i
< result
.number_matches
; i
++)
369 printf_unfiltered ("%s%s",
371 result
.match_list
[i
+ 1]);
373 printf_unfiltered ("%c", quote_char
);
374 printf_unfiltered ("\n");
378 if (result
.number_matches
== max_completions
)
380 /* ARG_PREFIX and WORD are included in the output so that emacs
381 will include the message in the output. */
382 printf_unfiltered (_("%s%s %s\n"),
383 arg_prefix
.c_str (), word
,
384 get_max_completions_reached_message ());
390 is_complete_command (struct cmd_list_element
*c
)
392 return cmd_cfunc_eq (c
, complete_command
);
396 show_version (const char *args
, int from_tty
)
398 print_gdb_version (gdb_stdout
, true);
399 printf_filtered ("\n");
403 show_configuration (const char *args
, int from_tty
)
405 print_gdb_configuration (gdb_stdout
);
408 /* Handle the quit command. */
411 quit_command (const char *args
, int from_tty
)
415 /* An optional expression may be used to cause gdb to terminate with
416 the value of that expression. */
419 struct value
*val
= parse_and_eval (args
);
421 exit_code
= (int) value_as_long (val
);
424 if (!quit_confirm ())
425 error (_("Not confirmed."));
427 query_if_trace_running (from_tty
);
429 quit_force (args
? &exit_code
: NULL
, from_tty
);
433 pwd_command (const char *args
, int from_tty
)
436 error (_("The \"pwd\" command does not take an argument: %s"), args
);
438 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
441 error (_("Error finding name of working directory: %s"),
442 safe_strerror (errno
));
444 if (strcmp (cwd
.get (), current_directory
) != 0)
445 printf_unfiltered (_("Working directory %ps\n (canonically %ps).\n"),
446 styled_string (file_name_style
.style (),
448 styled_string (file_name_style
.style (), cwd
.get ()));
450 printf_unfiltered (_("Working directory %ps.\n"),
451 styled_string (file_name_style
.style (),
456 cd_command (const char *dir
, int from_tty
)
459 /* Found something other than leading repetitions of "/..". */
463 /* If the new directory is absolute, repeat is a no-op; if relative,
464 repeat might be useful but is more likely to be a mistake. */
467 gdb::unique_xmalloc_ptr
<char> dir_holder
468 (tilde_expand (dir
!= NULL
? dir
: "~"));
469 dir
= dir_holder
.get ();
472 perror_with_name (dir
);
474 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
475 /* There's too much mess with DOSish names like "d:", "d:.",
476 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
477 simply get the canonicalized name of the current directory. */
478 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
483 if (IS_DIR_SEPARATOR (dir
[len
- 1]))
485 /* Remove the trailing slash unless this is a root directory
486 (including a drive letter on non-Unix systems). */
487 if (!(len
== 1) /* "/" */
488 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
489 && !(len
== 3 && dir
[1] == ':') /* "d:/" */
495 dir_holder
.reset (savestring (dir
, len
));
496 if (IS_ABSOLUTE_PATH (dir_holder
.get ()))
498 xfree (current_directory
);
499 current_directory
= dir_holder
.release ();
503 if (IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1]))
504 current_directory
= concat (current_directory
, dir_holder
.get (),
507 current_directory
= concat (current_directory
, SLASH_STRING
,
508 dir_holder
.get (), (char *) NULL
);
511 /* Now simplify any occurrences of `.' and `..' in the pathname. */
514 for (p
= current_directory
; *p
;)
516 if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.'
517 && (p
[2] == 0 || IS_DIR_SEPARATOR (p
[2])))
518 memmove (p
, p
+ 2, strlen (p
+ 2) + 1);
519 else if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.' && p
[2] == '.'
520 && (p
[3] == 0 || IS_DIR_SEPARATOR (p
[3])))
524 /* Search backwards for the directory just before the "/.."
525 and obliterate it and the "/..". */
528 while (q
!= current_directory
&& !IS_DIR_SEPARATOR (q
[-1]))
531 if (q
== current_directory
)
532 /* current_directory is
533 a relative pathname ("can't happen"--leave it alone). */
537 memmove (q
- 1, p
+ 3, strlen (p
+ 3) + 1);
542 /* We are dealing with leading repetitions of "/..", for
543 example "/../..", which is the Mach super-root. */
553 forget_cached_source_info ();
556 pwd_command ((char *) 0, 1);
559 /* Show the current value of the 'script-extension' option. */
562 show_script_ext_mode (struct ui_file
*file
, int from_tty
,
563 struct cmd_list_element
*c
, const char *value
)
565 fprintf_filtered (file
,
566 _("Script filename extension recognition is \"%s\".\n"),
570 /* Try to open SCRIPT_FILE.
571 If successful, the full path name is stored in *FULL_PATHP,
572 and the stream is returned.
573 If not successful, return NULL; errno is set for the last file
576 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
577 search for it in the source search path. */
579 gdb::optional
<open_script
>
580 find_and_open_script (const char *script_file
, int search_path
)
583 openp_flags search_flags
= OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
;
584 gdb::optional
<open_script
> opened
;
586 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (script_file
));
589 search_flags
|= OPF_SEARCH_IN_PATH
;
591 /* Search for and open 'file' on the search path used for source
592 files. Put the full location in *FULL_PATHP. */
593 gdb::unique_xmalloc_ptr
<char> full_path
;
594 fd
= openp (source_path
, search_flags
,
595 file
.get (), O_RDONLY
, &full_path
);
600 FILE *result
= fdopen (fd
, FOPEN_RT
);
603 int save_errno
= errno
;
609 opened
.emplace (gdb_file_up (result
), std::move (full_path
));
614 /* Load script FILE, which has already been opened as STREAM.
615 FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
616 This is provided as FILE may have been found via the source search path.
617 An important thing to note here is that FILE may be a symlink to a file
618 with a different or non-existing suffix, and thus one cannot infer the
619 extension language from FILE_TO_OPEN. */
622 source_script_from_stream (FILE *stream
, const char *file
,
623 const char *file_to_open
)
625 if (script_ext_mode
!= script_ext_off
)
627 const struct extension_language_defn
*extlang
628 = get_ext_lang_of_file (file
);
632 if (ext_lang_present_p (extlang
))
634 script_sourcer_func
*sourcer
635 = ext_lang_script_sourcer (extlang
);
637 gdb_assert (sourcer
!= NULL
);
638 sourcer (extlang
, stream
, file_to_open
);
641 else if (script_ext_mode
== script_ext_soft
)
643 /* Assume the file is a gdb script.
644 This is handled below. */
647 throw_ext_lang_unsupported (extlang
);
651 script_from_file (stream
, file
);
654 /* Worker to perform the "source" command.
656 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
657 search for it in the source search path. */
660 source_script_with_search (const char *file
, int from_tty
, int search_path
)
663 if (file
== NULL
|| *file
== 0)
664 error (_("source command requires file name of file to source."));
666 gdb::optional
<open_script
> opened
= find_and_open_script (file
, search_path
);
669 /* The script wasn't found, or was otherwise inaccessible.
670 If the source command was invoked interactively, throw an
671 error. Otherwise (e.g. if it was invoked by a script),
672 just emit a warning, rather than cause an error. */
674 perror_with_name (file
);
677 perror_warning_with_name (file
);
682 /* The python support reopens the file, so we need to pass full_path here
683 in case the file was found on the search path. It's useful to do this
684 anyway so that error messages show the actual file used. But only do
685 this if we (may have) used search_path, as printing the full path in
686 errors for the non-search case can be more noise than signal. */
687 source_script_from_stream (opened
->stream
.get (), file
,
688 search_path
? opened
->full_path
.get () : file
);
691 /* Wrapper around source_script_with_search to export it to main.c
692 for use in loading .gdbinit scripts. */
695 source_script (const char *file
, int from_tty
)
697 source_script_with_search (file
, from_tty
, 0);
701 source_command (const char *args
, int from_tty
)
703 const char *file
= args
;
706 scoped_restore save_source_verbose
= make_scoped_restore (&source_verbose
);
708 /* -v causes the source command to run in verbose mode.
709 -s causes the file to be searched in the source search path,
710 even if the file name contains a '/'.
711 We still have to be able to handle filenames with spaces in a
712 backward compatible way, so buildargv is not appropriate. */
716 while (args
[0] != '\0')
718 /* Make sure leading white space does not break the
720 args
= skip_spaces (args
);
725 if (args
[1] == 'v' && isspace (args
[2]))
729 /* Skip passed -v. */
732 else if (args
[1] == 's' && isspace (args
[2]))
736 /* Skip passed -s. */
743 file
= skip_spaces (args
);
746 source_script_with_search (file
, from_tty
, search_path
);
751 echo_command (const char *text
, int from_tty
)
753 const char *p
= text
;
757 while ((c
= *p
++) != '\0')
761 /* \ at end of argument is used after spaces
762 so they won't be lost. */
766 c
= parse_escape (get_current_arch (), &p
);
768 printf_filtered ("%c", c
);
771 printf_filtered ("%c", c
);
774 reset_terminal_style (gdb_stdout
);
776 /* Force this output to appear now. */
778 gdb_flush (gdb_stdout
);
781 /* Sets the last launched shell command convenience variables based on
785 exit_status_set_internal_vars (int exit_status
)
787 struct internalvar
*var_code
= lookup_internalvar ("_shell_exitcode");
788 struct internalvar
*var_signal
= lookup_internalvar ("_shell_exitsignal");
790 clear_internalvar (var_code
);
791 clear_internalvar (var_signal
);
792 if (WIFEXITED (exit_status
))
793 set_internalvar_integer (var_code
, WEXITSTATUS (exit_status
));
795 else if (WIFSIGNALED (exit_status
) && WTERMSIG (exit_status
) == -1)
797 /* The -1 condition can happen on MinGW, if we don't recognize
798 the fatal exception code encoded in the exit status; see
799 gdbsupport/gdb_wait.c. We don't want to lose information in
800 the exit status in that case. Record it as a normal exit
801 with the full exit status, including the higher 0xC0000000
803 set_internalvar_integer (var_code
, exit_status
);
806 else if (WIFSIGNALED (exit_status
))
807 set_internalvar_integer (var_signal
, WTERMSIG (exit_status
));
809 warning (_("unexpected shell command exit status %d"), exit_status
);
813 shell_escape (const char *arg
, int from_tty
)
815 #if defined(CANT_FORK) || \
816 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
817 /* If ARG is NULL, they want an inferior shell, but `system' just
818 reports if the shell is available when passed a NULL arg. */
819 int rc
= system (arg
? arg
: "");
822 arg
= "inferior shell";
825 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
826 safe_strerror (errno
));
828 fprintf_unfiltered (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
830 /* Make sure to return to the directory GDB thinks it is, in case
831 the shell command we just ran changed it. */
832 chdir (current_directory
);
833 exit_status_set_internal_vars (rc
);
835 #else /* Can fork. */
838 if ((pid
= vfork ()) == 0)
840 const char *p
, *user_shell
= get_shell ();
844 /* Get the name of the shell for arg0. */
845 p
= lbasename (user_shell
);
848 execl (user_shell
, p
, (char *) 0);
850 execl (user_shell
, p
, "-c", arg
, (char *) 0);
852 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
853 safe_strerror (errno
));
858 waitpid (pid
, &status
, 0);
860 error (_("Fork failed"));
861 exit_status_set_internal_vars (status
);
862 #endif /* Can fork. */
865 /* Implementation of the "shell" command. */
868 shell_command (const char *arg
, int from_tty
)
870 shell_escape (arg
, from_tty
);
874 edit_command (const char *arg
, int from_tty
)
876 struct symtab_and_line sal
;
882 /* Pull in the current default source line if necessary. */
885 set_default_source_symtab_and_line ();
886 sal
= get_current_source_symtab_and_line ();
889 /* Bare "edit" edits file with present line. */
894 error (_("No default source file yet."));
895 sal
.line
+= get_lines_to_list () / 2;
901 /* Now should only be one argument -- decode it in SAL. */
903 event_location_up location
= string_to_event_location (&arg1
,
905 std::vector
<symtab_and_line
> sals
= decode_line_1 (location
.get (),
906 DECODE_LINE_LIST_MODE
,
915 if (sals
.size () > 1)
917 ambiguous_line_spec (sals
,
918 _("Specified line is ambiguous:\n"));
925 error (_("Junk at end of line specification."));
927 /* If line was specified by address, first print exactly which
928 line, and which file. In this case, sal.symtab == 0 means
929 address is outside of all known source files, not that user
930 failed to give a filename. */
933 struct gdbarch
*gdbarch
;
936 error (_("No source file for address %s."),
937 paddress (get_current_arch (), sal
.pc
));
939 gdbarch
= SYMTAB_OBJFILE (sal
.symtab
)->arch ();
940 sym
= find_pc_function (sal
.pc
);
942 printf_filtered ("%s is in %s (%s:%d).\n",
943 paddress (gdbarch
, sal
.pc
),
945 symtab_to_filename_for_display (sal
.symtab
),
948 printf_filtered ("%s is at %s:%d.\n",
949 paddress (gdbarch
, sal
.pc
),
950 symtab_to_filename_for_display (sal
.symtab
),
954 /* If what was given does not imply a symtab, it must be an
955 undebuggable symbol which means no source code. */
958 error (_("No line number known for %s."), arg
);
961 if ((editor
= getenv ("EDITOR")) == NULL
)
964 fn
= symtab_to_fullname (sal
.symtab
);
966 /* Quote the file name, in case it has whitespace or other special
968 p
= xstrprintf ("%s +%d \"%s\"", editor
, sal
.line
, fn
);
969 shell_escape (p
, from_tty
);
973 /* The options for the "pipe" command. */
978 char *delimiter
= nullptr;
986 static const gdb::option::option_def pipe_cmd_option_defs
[] = {
988 gdb::option::string_option_def
<pipe_cmd_opts
> {
990 [] (pipe_cmd_opts
*opts
) { return &opts
->delimiter
; },
992 N_("Indicates to use the specified delimiter string to separate\n\
993 COMMAND from SHELL_COMMAND, in alternative to |. This is useful in\n\
994 case COMMAND contains a | character."),
999 /* Create an option_def_group for the "pipe" command's options, with
1002 static inline gdb::option::option_def_group
1003 make_pipe_cmd_options_def_group (pipe_cmd_opts
*opts
)
1005 return {{pipe_cmd_option_defs
}, opts
};
1008 /* Implementation of the "pipe" command. */
1011 pipe_command (const char *arg
, int from_tty
)
1015 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1016 gdb::option::process_options
1017 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
1019 const char *delim
= "|";
1020 if (opts
.delimiter
!= nullptr)
1021 delim
= opts
.delimiter
;
1023 const char *command
= arg
;
1024 if (command
== nullptr)
1025 error (_("Missing COMMAND"));
1027 arg
= strstr (arg
, delim
);
1030 error (_("Missing delimiter before SHELL_COMMAND"));
1032 std::string
gdb_cmd (command
, arg
- command
);
1034 arg
+= strlen (delim
); /* Skip the delimiter. */
1036 if (gdb_cmd
.empty ())
1037 gdb_cmd
= repeat_previous ();
1039 const char *shell_command
= skip_spaces (arg
);
1040 if (*shell_command
== '\0')
1041 error (_("Missing SHELL_COMMAND"));
1043 FILE *to_shell_command
= popen (shell_command
, "w");
1045 if (to_shell_command
== nullptr)
1046 error (_("Error launching \"%s\""), shell_command
);
1050 stdio_file
pipe_file (to_shell_command
);
1052 execute_command_to_ui_file (&pipe_file
, gdb_cmd
.c_str (), from_tty
);
1056 pclose (to_shell_command
);
1060 int exit_status
= pclose (to_shell_command
);
1062 if (exit_status
< 0)
1063 error (_("shell command \"%s\" failed: %s"), shell_command
,
1064 safe_strerror (errno
));
1065 exit_status_set_internal_vars (exit_status
);
1068 /* Completer for the pipe command. */
1071 pipe_command_completer (struct cmd_list_element
*ignore
,
1072 completion_tracker
&tracker
,
1073 const char *text
, const char *word_ignored
)
1077 const char *org_text
= text
;
1078 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1079 if (gdb::option::complete_options
1080 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
))
1083 const char *delimiter
= "|";
1084 if (opts
.delimiter
!= nullptr)
1085 delimiter
= opts
.delimiter
;
1087 /* Check if we're past option values already. */
1088 if (text
> org_text
&& !isspace (text
[-1]))
1091 const char *delim
= strstr (text
, delimiter
);
1093 /* If we're still not past the delimiter, complete the gdb
1095 if (delim
== nullptr || delim
== text
)
1097 complete_nested_command_line (tracker
, text
);
1101 /* We're past the delimiter. What follows is a shell command, which
1102 we don't know how to complete. */
1106 list_command (const char *arg
, int from_tty
)
1113 int linenum_beg
= 0;
1116 /* Pull in the current default source line if necessary. */
1117 if (arg
== NULL
|| ((arg
[0] == '+' || arg
[0] == '-') && arg
[1] == '\0'))
1119 set_default_source_symtab_and_line ();
1120 symtab_and_line cursal
= get_current_source_symtab_and_line ();
1122 /* If this is the first "list" since we've set the current
1123 source line, center the listing around that line. */
1124 if (get_first_line_listed () == 0)
1128 first
= std::max (cursal
.line
- get_lines_to_list () / 2, 1);
1130 /* A small special case --- if listing backwards, and we
1131 should list only one line, list the preceding line,
1132 instead of the exact line we've just shown after e.g.,
1133 stopping for a breakpoint. */
1134 if (arg
!= NULL
&& arg
[0] == '-'
1135 && get_lines_to_list () == 1 && first
> 1)
1138 print_source_lines (cursal
.symtab
, source_lines_range (first
), 0);
1141 /* "l" or "l +" lists next ten lines. */
1142 else if (arg
== NULL
|| arg
[0] == '+')
1143 print_source_lines (cursal
.symtab
,
1144 source_lines_range (cursal
.line
), 0);
1146 /* "l -" lists previous ten lines, the ones before the ten just
1148 else if (arg
[0] == '-')
1150 if (get_first_line_listed () == 1)
1151 error (_("Already at the start of %s."),
1152 symtab_to_filename_for_display (cursal
.symtab
));
1153 source_lines_range
range (get_first_line_listed (),
1154 source_lines_range::BACKWARD
);
1155 print_source_lines (cursal
.symtab
, range
, 0);
1161 /* Now if there is only one argument, decode it in SAL
1163 If there are two arguments, decode them in SAL and SAL_END
1164 and clear NO_END; however, if one of the arguments is blank,
1165 set DUMMY_BEG or DUMMY_END to record that fact. */
1167 if (!have_full_symbols () && !have_partial_symbols ())
1168 error (_("No symbol table is loaded. Use the \"file\" command."));
1170 std::vector
<symtab_and_line
> sals
;
1171 symtab_and_line sal
, sal_end
;
1178 event_location_up location
= string_to_event_location (&arg1
,
1180 sals
= decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1192 /* Record whether the BEG arg is all digits. */
1194 for (p
= arg
; p
!= arg1
&& *p
>= '0' && *p
<= '9'; p
++);
1195 linenum_beg
= (p
== arg1
);
1197 /* Save the range of the first argument, in case we need to let the
1198 user know it was ambiguous. */
1199 const char *beg
= arg
;
1200 size_t beg_len
= arg1
- beg
;
1202 while (*arg1
== ' ' || *arg1
== '\t')
1207 if (sals
.size () > 1)
1209 ambiguous_line_spec (sals
,
1210 _("Specified first line '%.*s' is ambiguous:\n"),
1211 (int) beg_len
, beg
);
1215 while (*arg1
== ' ' || *arg1
== '\t')
1221 /* Save the last argument, in case we need to let the user
1222 know it was ambiguous. */
1223 const char *end_arg
= arg1
;
1225 event_location_up location
1226 = string_to_event_location (&arg1
, current_language
);
1228 std::vector
<symtab_and_line
> sals_end
1230 ? decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1232 : decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1233 NULL
, sal
.symtab
, sal
.line
));
1235 filter_sals (sals_end
);
1236 if (sals_end
.empty ())
1238 if (sals_end
.size () > 1)
1240 ambiguous_line_spec (sals_end
,
1241 _("Specified last line '%s' is ambiguous:\n"),
1245 sal_end
= sals_end
[0];
1250 error (_("Junk at end of line specification."));
1252 if (!no_end
&& !dummy_beg
&& !dummy_end
1253 && sal
.symtab
!= sal_end
.symtab
)
1254 error (_("Specified first and last lines are in different files."));
1255 if (dummy_beg
&& dummy_end
)
1256 error (_("Two empty args do not say what lines to list."));
1258 /* If line was specified by address,
1259 first print exactly which line, and which file.
1261 In this case, sal.symtab == 0 means address is outside of all
1262 known source files, not that user failed to give a filename. */
1265 struct gdbarch
*gdbarch
;
1267 if (sal
.symtab
== 0)
1268 error (_("No source file for address %s."),
1269 paddress (get_current_arch (), sal
.pc
));
1271 gdbarch
= SYMTAB_OBJFILE (sal
.symtab
)->arch ();
1272 sym
= find_pc_function (sal
.pc
);
1274 printf_filtered ("%s is in %s (%s:%d).\n",
1275 paddress (gdbarch
, sal
.pc
),
1277 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1279 printf_filtered ("%s is at %s:%d.\n",
1280 paddress (gdbarch
, sal
.pc
),
1281 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1284 /* If line was not specified by just a line number, and it does not
1285 imply a symtab, it must be an undebuggable symbol which means no
1288 if (!linenum_beg
&& sal
.symtab
== 0)
1289 error (_("No line number known for %s."), arg
);
1291 /* If this command is repeated with RET,
1292 turn it into the no-arg variant. */
1295 set_repeat_arguments ("");
1297 if (dummy_beg
&& sal_end
.symtab
== 0)
1298 error (_("No default source file yet. Do \"help list\"."));
1301 source_lines_range
range (sal_end
.line
+ 1,
1302 source_lines_range::BACKWARD
);
1303 print_source_lines (sal_end
.symtab
, range
, 0);
1305 else if (sal
.symtab
== 0)
1306 error (_("No default source file yet. Do \"help list\"."));
1309 for (int i
= 0; i
< sals
.size (); i
++)
1312 int first_line
= sal
.line
- get_lines_to_list () / 2;
1315 if (sals
.size () > 1)
1316 print_sal_location (sal
);
1317 print_source_lines (sal
.symtab
, source_lines_range (first_line
), 0);
1321 print_source_lines (sal
.symtab
, source_lines_range (sal
.line
), 0);
1323 print_source_lines (sal
.symtab
,
1324 source_lines_range (sal
.line
, (sal_end
.line
+ 1)),
1328 /* Subroutine of disassemble_command to simplify it.
1329 Perform the disassembly.
1330 NAME is the name of the function if known, or NULL.
1331 [LOW,HIGH) are the range of addresses to disassemble.
1332 BLOCK is the block to disassemble; it needs to be provided
1333 when non-contiguous blocks are disassembled; otherwise
1335 MIXED is non-zero to print source with the assembler. */
1338 print_disassembly (struct gdbarch
*gdbarch
, const char *name
,
1339 CORE_ADDR low
, CORE_ADDR high
,
1340 const struct block
*block
,
1341 gdb_disassembly_flags flags
)
1344 if (tui_is_window_visible (DISASSEM_WIN
))
1345 tui_show_assembly (gdbarch
, low
);
1349 printf_filtered ("Dump of assembler code ");
1351 printf_filtered ("for function %s:\n", name
);
1352 if (block
== nullptr || BLOCK_CONTIGUOUS_P (block
))
1355 printf_filtered ("from %s to %s:\n",
1356 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
1358 /* Dump the specified range. */
1359 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1, low
, high
);
1363 for (int i
= 0; i
< BLOCK_NRANGES (block
); i
++)
1365 CORE_ADDR range_low
= BLOCK_RANGE_START (block
, i
);
1366 CORE_ADDR range_high
= BLOCK_RANGE_END (block
, i
);
1367 printf_filtered (_("Address range %s to %s:\n"),
1368 paddress (gdbarch
, range_low
),
1369 paddress (gdbarch
, range_high
));
1370 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1,
1371 range_low
, range_high
);
1374 printf_filtered ("End of assembler dump.\n");
1378 /* Subroutine of disassemble_command to simplify it.
1379 Print a disassembly of the current function according to FLAGS. */
1382 disassemble_current_function (gdb_disassembly_flags flags
)
1384 struct frame_info
*frame
;
1385 struct gdbarch
*gdbarch
;
1386 CORE_ADDR low
, high
, pc
;
1388 const struct block
*block
;
1390 frame
= get_selected_frame (_("No frame selected."));
1391 gdbarch
= get_frame_arch (frame
);
1392 pc
= get_frame_address_in_block (frame
);
1393 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1394 error (_("No function contains program counter for selected frame."));
1396 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1399 /* FIXME: cagney/2004-02-07: This should be an observer. */
1400 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1402 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1404 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1407 /* Dump a specified section of assembly code.
1411 - dump the assembly code for the function of the current pc
1412 disassemble [/mrs] addr
1413 - dump the assembly code for the function at ADDR
1414 disassemble [/mrs] low,high
1415 disassemble [/mrs] low,+length
1416 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1418 A /m modifier will include source code with the assembly in a
1419 "source centric" view. This view lists only the file of the first insn,
1420 even if other source files are involved (e.g., inlined functions), and
1421 the output is in source order, even with optimized code. This view is
1422 considered deprecated as it hasn't been useful in practice.
1424 A /r modifier will include raw instructions in hex with the assembly.
1426 A /s modifier will include source code with the assembly, like /m, with
1427 two important differences:
1428 1) The output is still in pc address order.
1429 2) File names and contents for all relevant source files are displayed. */
1432 disassemble_command (const char *arg
, int from_tty
)
1434 struct gdbarch
*gdbarch
= get_current_arch ();
1435 CORE_ADDR low
, high
;
1438 gdb_disassembly_flags flags
;
1440 const struct block
*block
= nullptr;
1451 error (_("Missing modifier."));
1453 while (*p
&& ! isspace (*p
))
1458 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1461 flags
|= DISASSEMBLY_RAW_INSN
;
1464 flags
|= DISASSEMBLY_SOURCE
;
1467 error (_("Invalid disassembly modifier."));
1471 p
= skip_spaces (p
);
1474 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1475 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1476 error (_("Cannot specify both /m and /s."));
1480 flags
|= DISASSEMBLY_OMIT_FNAME
;
1481 disassemble_current_function (flags
);
1485 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1491 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1492 error (_("No function contains specified address."));
1494 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1497 /* FIXME: cagney/2004-02-07: This should be an observer. */
1498 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1500 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1501 flags
|= DISASSEMBLY_OMIT_FNAME
;
1505 /* Two arguments. */
1508 p
= skip_spaces (p
);
1514 high
= parse_and_eval_address (p
);
1519 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1523 make_command (const char *arg
, int from_tty
)
1526 shell_escape ("make", from_tty
);
1529 std::string cmd
= std::string ("make ") + arg
;
1531 shell_escape (cmd
.c_str (), from_tty
);
1536 show_user (const char *args
, int from_tty
)
1538 struct cmd_list_element
*c
;
1542 const char *comname
= args
;
1544 c
= lookup_cmd (&comname
, cmdlist
, "", 0, 1);
1545 if (!cli_user_command_p (c
))
1546 error (_("Not a user command."));
1547 show_user_1 (c
, "", args
, gdb_stdout
);
1551 for (c
= cmdlist
; c
; c
= c
->next
)
1553 if (cli_user_command_p (c
) || c
->prefixlist
!= NULL
)
1554 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1559 /* Search through names of commands and documentations for a certain
1560 regular expression. */
1563 apropos_command (const char *arg
, int from_tty
)
1565 bool verbose
= arg
&& check_for_argument (&arg
, "-v", 2);
1567 if (arg
== NULL
|| *arg
== '\0')
1568 error (_("REGEXP string is empty"));
1570 compiled_regex
pattern (arg
, REG_ICASE
,
1571 _("Error in regular expression"));
1573 apropos_cmd (gdb_stdout
, cmdlist
, verbose
, pattern
, "");
1576 /* Subroutine of alias_command to simplify it.
1577 Return the first N elements of ARGV flattened back to a string
1578 with a space separating each element.
1579 ARGV may not be NULL.
1580 This does not take care of quoting elements in case they contain spaces
1584 argv_to_string (char **argv
, int n
)
1589 gdb_assert (argv
!= NULL
);
1590 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1592 for (i
= 0; i
< n
; ++i
)
1602 /* Subroutine of alias_command to simplify it.
1603 Return true if COMMAND exists, unambiguously. Otherwise false. */
1606 valid_command_p (const char *command
)
1608 struct cmd_list_element
*c
;
1610 c
= lookup_cmd_1 (& command
, cmdlist
, NULL
, 1);
1612 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1615 /* This is the slightly tricky part.
1616 lookup_cmd_1 will return a pointer to the last part of COMMAND
1617 to match, leaving COMMAND pointing at the remainder. */
1618 while (*command
== ' ' || *command
== '\t')
1620 return *command
== '\0';
1623 /* Called when "alias" was incorrectly used. */
1626 alias_usage_error (void)
1628 error (_("Usage: alias [-a] [--] ALIAS = COMMAND"));
1631 /* Make an alias of an existing command. */
1634 alias_command (const char *args
, int from_tty
)
1636 int i
, alias_argc
, command_argc
;
1637 int abbrev_flag
= 0;
1639 const char *alias
, *command
;
1641 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1642 alias_usage_error ();
1644 equals
= strchr (args
, '=');
1645 std::string
args2 (args
, equals
- args
);
1647 gdb_argv
built_alias_argv (args2
.c_str ());
1648 gdb_argv
command_argv (equals
+ 1);
1650 char **alias_argv
= built_alias_argv
.get ();
1651 while (alias_argv
[0] != NULL
)
1653 if (strcmp (alias_argv
[0], "-a") == 0)
1658 else if (strcmp (alias_argv
[0], "--") == 0)
1667 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1668 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1669 alias_usage_error ();
1671 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1673 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1676 error (_("Invalid command name: %s"), alias_argv
[i
]);
1678 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1682 alias_argc
= countargv (alias_argv
);
1683 command_argc
= command_argv
.count ();
1685 /* COMMAND must exist.
1686 Reconstruct the command to remove any extraneous spaces,
1687 for better error messages. */
1688 std::string
command_string (argv_to_string (command_argv
.get (),
1690 command
= command_string
.c_str ();
1691 if (! valid_command_p (command
))
1692 error (_("Invalid command to alias to: %s"), command
);
1694 /* ALIAS must not exist. */
1695 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1696 alias
= alias_string
.c_str ();
1698 cmd_list_element
*alias_cmd
, *prefix_cmd
, *cmd
;
1700 if (lookup_cmd_composition (alias
, &alias_cmd
, &prefix_cmd
, &cmd
))
1702 const char *alias_name
= alias_argv
[alias_argc
-1];
1704 /* If we found an existing ALIAS_CMD, check that the prefix differ or
1707 if (alias_cmd
!= nullptr
1708 && alias_cmd
->prefix
== prefix_cmd
1709 && strcmp (alias_name
, alias_cmd
->name
) == 0)
1710 error (_("Alias already exists: %s"), alias
);
1712 /* Check ALIAS differs from the found CMD. */
1714 if (cmd
->prefix
== prefix_cmd
1715 && strcmp (alias_name
, cmd
->name
) == 0)
1716 error (_("Alias %s is the name of an existing command"), alias
);
1721 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1722 Example: alias spe = set print elements
1724 Otherwise ALIAS and COMMAND must have the same number of words,
1725 and every word except the last must identify the same prefix command;
1726 and the last word of ALIAS is made an alias of the last word of COMMAND.
1727 Example: alias set print elms = set pr elem
1728 Note that unambiguous abbreviations are allowed. */
1730 if (alias_argc
== 1)
1732 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1733 add_com_alias (xstrdup (alias_argv
[0]), command
, class_alias
,
1738 const char *alias_prefix
, *command_prefix
;
1739 struct cmd_list_element
*c_alias
, *c_command
;
1741 if (alias_argc
!= command_argc
)
1742 error (_("Mismatched command length between ALIAS and COMMAND."));
1744 /* Create copies of ALIAS and COMMAND without the last word,
1745 and use that to verify the leading elements give the same
1747 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1749 std::string
command_prefix_string (argv_to_string (command_argv
.get (),
1751 alias_prefix
= alias_prefix_string
.c_str ();
1752 command_prefix
= command_prefix_string
.c_str ();
1754 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, 1);
1755 /* We've already tried to look up COMMAND. */
1756 gdb_assert (c_command
!= NULL
1757 && c_command
!= (struct cmd_list_element
*) -1);
1758 gdb_assert (c_command
->prefixlist
!= NULL
);
1759 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, 1);
1760 if (c_alias
!= c_command
)
1761 error (_("ALIAS and COMMAND prefixes do not match."));
1763 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1764 add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1765 command_argv
[command_argc
- 1],
1766 class_alias
, abbrev_flag
, c_command
->prefixlist
);
1770 /* Print the file / line number / symbol name of the location
1771 specified by SAL. */
1774 print_sal_location (const symtab_and_line
&sal
)
1776 scoped_restore_current_program_space restore_pspace
;
1777 set_current_program_space (sal
.pspace
);
1779 const char *sym_name
= NULL
;
1780 if (sal
.symbol
!= NULL
)
1781 sym_name
= sal
.symbol
->print_name ();
1782 printf_filtered (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
1783 symtab_to_filename_for_display (sal
.symtab
),
1784 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
1787 /* Print a list of files and line numbers which a user may choose from
1788 in order to list a function which was specified ambiguously (as
1789 with `list classname::overloadedfuncname', for example). The SALS
1790 array provides the filenames and line numbers. FORMAT is a
1791 printf-style format string used to tell the user what was
1795 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
1796 const char *format
, ...)
1799 va_start (ap
, format
);
1800 vprintf_filtered (format
, ap
);
1803 for (const auto &sal
: sals
)
1804 print_sal_location (sal
);
1807 /* Comparison function for filter_sals. Returns a qsort-style
1811 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1813 const char *dira
= SYMTAB_DIRNAME (sala
.symtab
);
1814 const char *dirb
= SYMTAB_DIRNAME (salb
.symtab
);
1822 else if (dirb
== NULL
)
1829 r
= filename_cmp (dira
, dirb
);
1834 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
1838 if (sala
.line
< salb
.line
)
1840 return sala
.line
== salb
.line
? 0 : 1;
1843 /* Remove any SALs that do not match the current program space, or
1844 which appear to be "file:line" duplicates. */
1847 filter_sals (std::vector
<symtab_and_line
> &sals
)
1849 /* Remove SALs that do not match. */
1850 auto from
= std::remove_if (sals
.begin (), sals
.end (),
1851 [&] (const symtab_and_line
&sal
)
1852 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
1855 std::sort (sals
.begin (), from
,
1856 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1857 { return cmp_symtabs (sala
, salb
) < 0; });
1859 from
= std::unique (sals
.begin (), from
,
1860 [&] (const symtab_and_line
&sala
,
1861 const symtab_and_line
&salb
)
1862 { return cmp_symtabs (sala
, salb
) == 0; });
1864 sals
.erase (from
, sals
.end ());
1868 init_cmd_lists (void)
1870 max_user_call_depth
= 1024;
1874 show_info_verbose (struct ui_file
*file
, int from_tty
,
1875 struct cmd_list_element
*c
,
1879 fprintf_filtered (file
,
1880 _("Verbose printing of informational messages is %s.\n"),
1883 fprintf_filtered (file
, _("Verbosity is %s.\n"), value
);
1887 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
1888 struct cmd_list_element
*c
, const char *value
)
1890 fprintf_filtered (file
, _("History expansion on command input is %s.\n"),
1895 show_remote_debug (struct ui_file
*file
, int from_tty
,
1896 struct cmd_list_element
*c
, const char *value
)
1898 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
1903 show_remote_timeout (struct ui_file
*file
, int from_tty
,
1904 struct cmd_list_element
*c
, const char *value
)
1906 fprintf_filtered (file
,
1907 _("Timeout limit to wait for target to respond is %s.\n"),
1912 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
1913 struct cmd_list_element
*c
, const char *value
)
1915 fprintf_filtered (file
,
1916 _("The max call depth for user-defined commands is %s.\n"),
1920 /* Returns the cmd_list_element in SHOWLIST corresponding to the first
1921 argument of ARGV, which must contain one single value.
1922 Throws an error if no value provided, or value not correct.
1923 FNNAME is used in the error message. */
1925 static cmd_list_element
*
1926 setting_cmd (const char *fnname
, struct cmd_list_element
*showlist
,
1927 int argc
, struct value
**argv
)
1930 error (_("You must provide an argument to %s"), fnname
);
1932 error (_("You can only provide one argument to %s"), fnname
);
1934 struct type
*type0
= check_typedef (value_type (argv
[0]));
1936 if (type0
->code () != TYPE_CODE_ARRAY
1937 && type0
->code () != TYPE_CODE_STRING
)
1938 error (_("First argument of %s must be a string."), fnname
);
1940 const char *a0
= (const char *) value_contents (argv
[0]);
1941 cmd_list_element
*cmd
= lookup_cmd (&a0
, showlist
, "", -1, 0);
1943 if (cmd
== nullptr || cmd_type (cmd
) != show_cmd
)
1944 error (_("First argument of %s must be a "
1945 "valid setting of the 'show' command."), fnname
);
1950 /* Builds a value from the show CMD. */
1952 static struct value
*
1953 value_from_setting (const cmd_list_element
*cmd
, struct gdbarch
*gdbarch
)
1955 switch (cmd
->var_type
)
1958 if (*(int *) cmd
->var
== INT_MAX
)
1959 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1962 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1965 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1968 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1969 *(bool *) cmd
->var
? 1 : 0);
1970 case var_zuinteger_unlimited
:
1971 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1973 case var_auto_boolean
:
1977 switch (*(enum auto_boolean
*) cmd
->var
)
1979 case AUTO_BOOLEAN_TRUE
:
1982 case AUTO_BOOLEAN_FALSE
:
1985 case AUTO_BOOLEAN_AUTO
:
1989 gdb_assert_not_reached ("invalid var_auto_boolean");
1991 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
1995 if (*(unsigned int *) cmd
->var
== UINT_MAX
)
1996 return value_from_ulongest
1997 (builtin_type (gdbarch
)->builtin_unsigned_int
, 0);
1999 return value_from_ulongest
2000 (builtin_type (gdbarch
)->builtin_unsigned_int
,
2001 *(unsigned int *) cmd
->var
);
2003 return value_from_ulongest (builtin_type (gdbarch
)->builtin_unsigned_int
,
2004 *(unsigned int *) cmd
->var
);
2006 case var_string_noescape
:
2007 case var_optional_filename
:
2010 if (*(char **) cmd
->var
)
2011 return value_cstring (*(char **) cmd
->var
, strlen (*(char **) cmd
->var
),
2012 builtin_type (gdbarch
)->builtin_char
);
2014 return value_cstring ("", 1,
2015 builtin_type (gdbarch
)->builtin_char
);
2017 gdb_assert_not_reached ("bad var_type");
2021 /* Implementation of the convenience function $_gdb_setting. */
2023 static struct value
*
2024 gdb_setting_internal_fn (struct gdbarch
*gdbarch
,
2025 const struct language_defn
*language
,
2026 void *cookie
, int argc
, struct value
**argv
)
2028 return value_from_setting (setting_cmd ("$_gdb_setting", showlist
,
2033 /* Implementation of the convenience function $_gdb_maint_setting. */
2035 static struct value
*
2036 gdb_maint_setting_internal_fn (struct gdbarch
*gdbarch
,
2037 const struct language_defn
*language
,
2038 void *cookie
, int argc
, struct value
**argv
)
2040 return value_from_setting (setting_cmd ("$_gdb_maint_setting",
2041 maintenance_show_cmdlist
,
2046 /* Builds a string value from the show CMD. */
2048 static struct value
*
2049 str_value_from_setting (const cmd_list_element
*cmd
, struct gdbarch
*gdbarch
)
2051 switch (cmd
->var_type
)
2056 case var_zuinteger_unlimited
:
2057 case var_auto_boolean
:
2061 std::string cmd_val
= get_setshow_command_value_string (cmd
);
2063 return value_cstring (cmd_val
.c_str (), cmd_val
.size (),
2064 builtin_type (gdbarch
)->builtin_char
);
2068 case var_string_noescape
:
2069 case var_optional_filename
:
2072 /* For these cases, we do not use get_setshow_command_value_string,
2073 as this function handle some characters specially, e.g. by
2074 escaping quotes. So, we directly use the cmd->var string value,
2075 similarly to the value_from_setting code for these cases. */
2076 if (*(char **) cmd
->var
)
2077 return value_cstring (*(char **) cmd
->var
, strlen (*(char **) cmd
->var
),
2078 builtin_type (gdbarch
)->builtin_char
);
2080 return value_cstring ("", 1,
2081 builtin_type (gdbarch
)->builtin_char
);
2084 gdb_assert_not_reached ("bad var_type");
2088 /* Implementation of the convenience function $_gdb_setting_str. */
2090 static struct value
*
2091 gdb_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2092 const struct language_defn
*language
,
2093 void *cookie
, int argc
, struct value
**argv
)
2095 return str_value_from_setting (setting_cmd ("$_gdb_setting_str",
2096 showlist
, argc
, argv
),
2101 /* Implementation of the convenience function $_gdb_maint_setting_str. */
2103 static struct value
*
2104 gdb_maint_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2105 const struct language_defn
*language
,
2106 void *cookie
, int argc
, struct value
**argv
)
2108 return str_value_from_setting (setting_cmd ("$_gdb_maint_setting_str",
2109 maintenance_show_cmdlist
,
2114 void _initialize_cli_cmds ();
2116 _initialize_cli_cmds ()
2118 struct cmd_list_element
*c
;
2120 /* Define the classes of commands.
2121 They will appear in the help list in alphabetical order. */
2123 add_cmd ("internals", class_maintenance
, _("\
2124 Maintenance commands.\n\
2125 Some gdb commands are provided just for use by gdb maintainers.\n\
2126 These commands are subject to frequent change, and may not be as\n\
2127 well documented as user commands."),
2129 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
2130 add_cmd ("aliases", class_alias
,
2131 _("Aliases of other commands."), &cmdlist
);
2132 add_cmd ("user-defined", class_user
, _("\
2133 User-defined commands.\n\
2134 The commands in this class are those defined by the user.\n\
2135 Use the \"define\" command to define a command."), &cmdlist
);
2136 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
2138 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
2139 add_cmd ("files", class_files
, _("Specifying and examining files."),
2141 add_cmd ("breakpoints", class_breakpoint
,
2142 _("Making program stop at certain points."), &cmdlist
);
2143 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
2144 add_cmd ("stack", class_stack
, _("\
2145 Examining the stack.\n\
2146 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
2147 counting from zero for the innermost (currently executing) frame.\n\n\
2148 At any time gdb identifies one frame as the \"selected\" frame.\n\
2149 Variable lookups are done with respect to the selected frame.\n\
2150 When the program being debugged stops, gdb selects the innermost frame.\n\
2151 The commands below can be used to select other frames by number or address."),
2153 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
2155 /* Define general commands. */
2157 add_com ("pwd", class_files
, pwd_command
, _("\
2158 Print working directory.\n\
2159 This is used for your program as well."));
2161 c
= add_cmd ("cd", class_files
, cd_command
, _("\
2162 Set working directory to DIR for debugger.\n\
2163 The debugger's current working directory specifies where scripts and other\n\
2164 files that can be loaded by GDB are located.\n\
2165 In order to change the inferior's current working directory, the recommended\n\
2166 way is to use the \"set cwd\" command."), &cmdlist
);
2167 set_cmd_completer (c
, filename_completer
);
2169 add_com ("echo", class_support
, echo_command
, _("\
2170 Print a constant string. Give string as argument.\n\
2171 C escape sequences may be used in the argument.\n\
2172 No newline is added at the end of the argument;\n\
2173 use \"\\n\" if you want a newline to be printed.\n\
2174 Since leading and trailing whitespace are ignored in command arguments,\n\
2175 if you want to print some you must use \"\\\" before leading whitespace\n\
2176 to be printed or after trailing whitespace."));
2178 add_setshow_enum_cmd ("script-extension", class_support
,
2179 script_ext_enums
, &script_ext_mode
, _("\
2180 Set mode for script filename extension recognition."), _("\
2181 Show mode for script filename extension recognition."), _("\
2182 off == no filename extension recognition (all sourced files are GDB scripts)\n\
2183 soft == evaluate script according to filename extension, fallback to GDB script"
2185 strict == evaluate script according to filename extension, error if not supported"
2188 show_script_ext_mode
,
2189 &setlist
, &showlist
);
2191 add_com ("quit", class_support
, quit_command
, _("\
2193 Usage: quit [EXPR]\n\
2194 The optional expression EXPR, if present, is evaluated and the result\n\
2195 used as GDB's exit code. The default is zero."));
2196 c
= add_com ("help", class_support
, help_command
,
2197 _("Print list of commands."));
2198 set_cmd_completer (c
, command_completer
);
2199 add_com_alias ("q", "quit", class_support
, 1);
2200 add_com_alias ("h", "help", class_support
, 1);
2202 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
2203 Set verbosity."), _("\
2204 Show verbosity."), NULL
,
2207 &setlist
, &showlist
);
2209 add_basic_prefix_cmd ("history", class_support
, _("\
2210 Generic command for setting command history parameters."),
2211 &sethistlist
, "set history ", 0, &setlist
);
2212 add_show_prefix_cmd ("history", class_support
, _("\
2213 Generic command for showing command history parameters."),
2214 &showhistlist
, "show history ", 0, &showlist
);
2216 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
2217 Set history expansion on command input."), _("\
2218 Show history expansion on command input."), _("\
2219 Without an argument, history expansion is enabled."),
2221 show_history_expansion_p
,
2222 &sethistlist
, &showhistlist
);
2224 add_prefix_cmd ("info", class_info
, info_command
, _("\
2225 Generic command for showing things about the program being debugged."),
2226 &infolist
, "info ", 0, &cmdlist
);
2227 add_com_alias ("i", "info", class_info
, 1);
2228 add_com_alias ("inf", "info", class_info
, 1);
2230 add_com ("complete", class_obscure
, complete_command
,
2231 _("List the completions for the rest of the line as a command."));
2233 c
= add_show_prefix_cmd ("show", class_info
, _("\
2234 Generic command for showing things about the debugger."),
2235 &showlist
, "show ", 0, &cmdlist
);
2236 /* Another way to get at the same thing. */
2237 add_alias_cmd ("set", c
, class_info
, 0, &infolist
);
2239 c
= add_com ("with", class_vars
, with_command
, _("\
2240 Temporarily set SETTING to VALUE, run COMMAND, and restore SETTING.\n\
2241 Usage: with SETTING [VALUE] [-- COMMAND]\n\
2242 Usage: w SETTING [VALUE] [-- COMMAND]\n\
2243 With no COMMAND, repeats the last executed command.\n\
2245 SETTING is any setting you can change with the \"set\" subcommands.\n\
2247 with language pascal -- print obj\n\
2248 with print elements unlimited -- print obj\n\
2250 You can change multiple settings using nested with, and use\n\
2251 abbreviations for commands and/or values. E.g.:\n\
2252 w la p -- w p el u -- p obj"));
2253 set_cmd_completer_handle_brkchars (c
, with_command_completer
);
2254 add_com_alias ("w", "with", class_vars
, 1);
2256 add_internal_function ("_gdb_setting_str", _("\
2257 $_gdb_setting_str - returns the value of a GDB setting as a string.\n\
2258 Usage: $_gdb_setting_str (setting)\n\
2260 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2261 boolean values are \"off\", \"on\".\n\
2262 Some integer settings accept an unlimited value, returned\n\
2263 as \"unlimited\"."),
2264 gdb_setting_str_internal_fn
, NULL
);
2266 add_internal_function ("_gdb_setting", _("\
2267 $_gdb_setting - returns the value of a GDB setting.\n\
2268 Usage: $_gdb_setting (setting)\n\
2269 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2270 boolean values are \"off\", \"on\".\n\
2271 Some integer settings accept an unlimited value, returned\n\
2272 as 0 or -1 depending on the setting."),
2273 gdb_setting_internal_fn
, NULL
);
2275 add_internal_function ("_gdb_maint_setting_str", _("\
2276 $_gdb_maint_setting_str - returns the value of a GDB maintenance setting as a string.\n\
2277 Usage: $_gdb_maint_setting_str (setting)\n\
2279 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2280 boolean values are \"off\", \"on\".\n\
2281 Some integer settings accept an unlimited value, returned\n\
2282 as \"unlimited\"."),
2283 gdb_maint_setting_str_internal_fn
, NULL
);
2285 add_internal_function ("_gdb_maint_setting", _("\
2286 $_gdb_maint_setting - returns the value of a GDB maintenance setting.\n\
2287 Usage: $_gdb_maint_setting (setting)\n\
2288 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2289 boolean values are \"off\", \"on\".\n\
2290 Some integer settings accept an unlimited value, returned\n\
2291 as 0 or -1 depending on the setting."),
2292 gdb_maint_setting_internal_fn
, NULL
);
2294 add_cmd ("commands", no_set_class
, show_commands
, _("\
2295 Show the history of commands you typed.\n\
2296 You can supply a command number to start with, or a `+' to start after\n\
2297 the previous command number shown."),
2300 add_cmd ("version", no_set_class
, show_version
,
2301 _("Show what version of GDB this is."), &showlist
);
2303 add_cmd ("configuration", no_set_class
, show_configuration
,
2304 _("Show how GDB was configured at build time."), &showlist
);
2306 add_setshow_zinteger_cmd ("remote", no_class
, &remote_debug
, _("\
2307 Set debugging of remote protocol."), _("\
2308 Show debugging of remote protocol."), _("\
2309 When enabled, each packet sent or received with the remote target\n\
2313 &setdebuglist
, &showdebuglist
);
2315 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
2316 &remote_timeout
, _("\
2317 Set timeout limit to wait for target to respond."), _("\
2318 Show timeout limit to wait for target to respond."), _("\
2319 This value is used to set the time limit for gdb to wait for a response\n\
2322 show_remote_timeout
,
2323 &setlist
, &showlist
);
2325 add_basic_prefix_cmd ("debug", no_class
,
2326 _("Generic command for setting gdb debugging flags."),
2327 &setdebuglist
, "set debug ", 0, &setlist
);
2329 add_show_prefix_cmd ("debug", no_class
,
2330 _("Generic command for showing gdb debugging flags."),
2331 &showdebuglist
, "show debug ", 0, &showlist
);
2333 c
= add_com ("shell", class_support
, shell_command
, _("\
2334 Execute the rest of the line as a shell command.\n\
2335 With no arguments, run an inferior shell."));
2336 set_cmd_completer (c
, filename_completer
);
2338 add_com_alias ("!", "shell", class_support
, 0);
2340 c
= add_com ("edit", class_files
, edit_command
, _("\
2341 Edit specified file or function.\n\
2342 With no argument, edits file containing most recent line listed.\n\
2343 Editing targets can be specified in these ways:\n\
2344 FILE:LINENUM, to edit at that line in that file,\n\
2345 FUNCTION, to edit at the beginning of that function,\n\
2346 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2347 *ADDRESS, to edit at the line containing that address.\n\
2348 Uses EDITOR environment variable contents as editor (or ex as default)."));
2350 c
->completer
= location_completer
;
2352 c
= add_com ("pipe", class_support
, pipe_command
, _("\
2353 Send the output of a gdb command to a shell command.\n\
2354 Usage: | [COMMAND] | SHELL_COMMAND\n\
2355 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2356 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
2357 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2359 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
2361 The -d option indicates to use the string DELIM to separate COMMAND\n\
2362 from SHELL_COMMAND, in alternative to |. This is useful in\n\
2363 case COMMAND contains a | character.\n\
2365 With no COMMAND, repeat the last executed command\n\
2366 and send its output to SHELL_COMMAND."));
2367 set_cmd_completer_handle_brkchars (c
, pipe_command_completer
);
2368 add_com_alias ("|", "pipe", class_support
, 0);
2370 add_com ("list", class_files
, list_command
, _("\
2371 List specified function or line.\n\
2372 With no argument, lists ten more lines after or around previous listing.\n\
2373 \"list -\" lists the ten lines before a previous ten-line listing.\n\
2374 One argument specifies a line, and ten lines are listed around that line.\n\
2375 Two arguments with comma between specify starting and ending lines to list.\n\
2376 Lines can be specified in these ways:\n\
2377 LINENUM, to list around that line in current file,\n\
2378 FILE:LINENUM, to list around that line in that file,\n\
2379 FUNCTION, to list around beginning of that function,\n\
2380 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2381 *ADDRESS, to list around the line containing that address.\n\
2382 With two args, if one is empty, it stands for ten lines away from\n\
2385 By default, when a single location is given, display ten lines.\n\
2386 This can be changed using \"set listsize\", and the current value\n\
2387 can be shown using \"show listsize\"."));
2389 add_com_alias ("l", "list", class_files
, 1);
2392 add_com_alias ("file", "list", class_files
, 1);
2394 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
2395 Disassemble a specified section of memory.\n\
2396 Default is the function surrounding the pc of the selected frame.\n\
2398 With a /m modifier, source lines are included (if available).\n\
2399 This view is \"source centric\": the output is in source line order,\n\
2400 regardless of any optimization that is present. Only the main source file\n\
2401 is displayed, not those of, e.g., any inlined functions.\n\
2402 This modifier hasn't proved useful in practice and is deprecated\n\
2405 With a /s modifier, source lines are included (if available).\n\
2406 This differs from /m in two important respects:\n\
2407 - the output is still in pc address order, and\n\
2408 - file names and contents for all relevant source files are displayed.\n\
2410 With a /r modifier, raw instructions in hex are included.\n\
2412 With a single argument, the function surrounding that address is dumped.\n\
2413 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
2414 in the form of \"start,end\", or \"start,+length\".\n\
2416 Note that the address is interpreted as an expression, not as a location\n\
2417 like in the \"break\" command.\n\
2418 So, for example, if you want to disassemble function bar in file foo.c\n\
2419 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
2420 set_cmd_completer (c
, location_completer
);
2422 c
= add_com ("make", class_support
, make_command
, _("\
2423 Run the ``make'' program using the rest of the line as arguments."));
2424 set_cmd_completer (c
, filename_completer
);
2425 add_cmd ("user", no_class
, show_user
, _("\
2426 Show definitions of non-python/scheme user defined commands.\n\
2427 Argument is the name of the user defined command.\n\
2428 With no argument, show definitions of all user defined commands."), &showlist
);
2429 add_com ("apropos", class_support
, apropos_command
, _("\
2430 Search for commands matching a REGEXP.\n\
2431 Usage: apropos [-v] REGEXP\n\
2432 Flag -v indicates to produce a verbose output, showing full documentation\n\
2433 of the matching commands."));
2435 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
2436 &max_user_call_depth
, _("\
2437 Set the max call depth for non-python/scheme user-defined commands."), _("\
2438 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
2440 show_max_user_call_depth
,
2441 &setlist
, &showlist
);
2443 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
2444 Set tracing of GDB CLI commands."), _("\
2445 Show state of GDB CLI command tracing."), _("\
2446 When 'on', each command is displayed as it is executed."),
2449 &setlist
, &showlist
);
2451 c
= add_com ("alias", class_support
, alias_command
, _("\
2452 Define a new command that is an alias of an existing command.\n\
2453 Usage: alias [-a] [--] ALIAS = COMMAND\n\
2454 ALIAS is the name of the alias command to create.\n\
2455 COMMAND is the command being aliased to.\n\
2456 If \"-a\" is specified, the command is an abbreviation,\n\
2457 and will not be used in command completion.\n\
2460 Make \"spe\" an alias of \"set print elements\":\n\
2461 alias spe = set print elements\n\
2462 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2463 alias -a set print elms = set print elements"));
2465 const char *source_help_text
= xstrprintf (_("\
2466 Read commands from a file named FILE.\n\
2468 Usage: source [-s] [-v] FILE\n\
2469 -s: search for the script in the source search path,\n\
2470 even if FILE contains directories.\n\
2471 -v: each command in FILE is echoed as it is executed.\n\
2473 Note that the file \"%s\" is read automatically in this way\n\
2474 when GDB is started."), GDBINIT
);
2475 c
= add_cmd ("source", class_support
, source_command
,
2476 source_help_text
, &cmdlist
);
2477 set_cmd_completer (c
, filename_completer
);