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"
53 #include "cli/cli-style.h"
55 #include "extension.h"
56 #include "gdbsupport/pathstuff.h"
59 #include "tui/tui.h" /* For tui_active et.al. */
66 /* Prototypes for local utility functions */
68 static void print_sal_location (const symtab_and_line
&sal
);
70 static void ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
71 const char *format
, ...)
72 ATTRIBUTE_PRINTF (2, 3);
74 static void filter_sals (std::vector
<symtab_and_line
> &);
78 unsigned int max_user_call_depth
;
80 /* Define all cmd_list_elements. */
82 /* Chain containing all defined commands. */
84 struct cmd_list_element
*cmdlist
;
86 /* Chain containing all defined info subcommands. */
88 struct cmd_list_element
*infolist
;
90 /* Chain containing all defined enable subcommands. */
92 struct cmd_list_element
*enablelist
;
94 /* Chain containing all defined disable subcommands. */
96 struct cmd_list_element
*disablelist
;
98 /* Chain containing all defined stop subcommands. */
100 struct cmd_list_element
*stoplist
;
102 /* Chain containing all defined delete subcommands. */
104 struct cmd_list_element
*deletelist
;
106 /* Chain containing all defined detach subcommands. */
108 struct cmd_list_element
*detachlist
;
110 /* Chain containing all defined kill subcommands. */
112 struct cmd_list_element
*killlist
;
114 /* Chain containing all defined set subcommands */
116 struct cmd_list_element
*setlist
;
118 /* Chain containing all defined unset subcommands */
120 struct cmd_list_element
*unsetlist
;
122 /* Chain containing all defined show subcommands. */
124 struct cmd_list_element
*showlist
;
126 /* Chain containing all defined \"set history\". */
128 struct cmd_list_element
*sethistlist
;
130 /* Chain containing all defined \"show history\". */
132 struct cmd_list_element
*showhistlist
;
134 /* Chain containing all defined \"unset history\". */
136 struct cmd_list_element
*unsethistlist
;
138 /* Chain containing all defined maintenance subcommands. */
140 struct cmd_list_element
*maintenancelist
;
142 /* Chain containing all defined "maintenance info" subcommands. */
144 struct cmd_list_element
*maintenanceinfolist
;
146 /* Chain containing all defined "maintenance print" subcommands. */
148 struct cmd_list_element
*maintenanceprintlist
;
150 /* Chain containing all defined "maintenance check" subcommands. */
152 struct cmd_list_element
*maintenancechecklist
;
154 struct cmd_list_element
*setprintlist
;
156 struct cmd_list_element
*showprintlist
;
158 struct cmd_list_element
*setdebuglist
;
160 struct cmd_list_element
*showdebuglist
;
162 struct cmd_list_element
*setchecklist
;
164 struct cmd_list_element
*showchecklist
;
166 /* Command tracing state. */
168 int source_verbose
= 0;
169 bool trace_commands
= false;
171 /* 'script-extension' option support. */
173 static const char script_ext_off
[] = "off";
174 static const char script_ext_soft
[] = "soft";
175 static const char script_ext_strict
[] = "strict";
177 static const char *const script_ext_enums
[] = {
184 static const char *script_ext_mode
= script_ext_soft
;
186 /* Utility used everywhere when at least one argument is needed and
190 error_no_arg (const char *why
)
192 error (_("Argument required (%s)."), why
);
195 /* This implements the "info" prefix command. Normally such commands
196 are automatically handled by add_basic_prefix_cmd, but in this case
197 a separate command is used so that it can be hooked into by
201 info_command (const char *arg
, int from_tty
)
203 help_list (infolist
, "info ", all_commands
, gdb_stdout
);
206 /* See cli/cli-cmds.h. */
209 with_command_1 (const char *set_cmd_prefix
,
210 cmd_list_element
*setlist
, const char *args
, int from_tty
)
213 error (_("Missing arguments."));
215 const char *delim
= strstr (args
, "--");
216 const char *nested_cmd
= nullptr;
219 error (_("Missing setting before '--' delimiter"));
221 if (delim
== nullptr || *skip_spaces (&delim
[2]) == '\0')
222 nested_cmd
= repeat_previous ();
224 cmd_list_element
*set_cmd
= lookup_cmd (&args
, setlist
, set_cmd_prefix
,
226 /*allow_unknown=*/ 0,
227 /*ignore_help_classes=*/ 1);
228 gdb_assert (set_cmd
!= nullptr);
230 if (set_cmd
->var
== nullptr)
231 error (_("Cannot use this setting with the \"with\" command"));
233 std::string temp_value
234 = (delim
== nullptr ? args
: std::string (args
, delim
- args
));
236 if (nested_cmd
== nullptr)
237 nested_cmd
= skip_spaces (delim
+ 2);
239 std::string org_value
= get_setshow_command_value_string (set_cmd
);
241 /* Tweak the setting to the new temporary value. */
242 do_set_command (temp_value
.c_str (), from_tty
, set_cmd
);
246 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
248 /* Execute the nested command. */
249 execute_command (nested_cmd
, from_tty
);
251 catch (const gdb_exception
&ex
)
253 /* Restore the setting and rethrow. If restoring the setting
254 throws, swallow the new exception and warn. There's nothing
255 else we can reasonably do. */
258 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
260 catch (const gdb_exception
&ex2
)
262 warning (_("Couldn't restore setting: %s"), ex2
.what ());
268 /* Restore the setting. */
269 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
272 /* See cli/cli-cmds.h. */
275 with_command_completer_1 (const char *set_cmd_prefix
,
276 completion_tracker
&tracker
,
279 tracker
.set_use_custom_word_point (true);
281 const char *delim
= strstr (text
, "--");
283 /* If we're still not past the "--" delimiter, complete the "with"
284 command as if it was a "set" command. */
287 || !isspace (delim
[-1])
288 || !(isspace (delim
[2]) || delim
[2] == '\0'))
290 std::string new_text
= std::string (set_cmd_prefix
) + text
;
291 tracker
.advance_custom_word_point_by (-(int) strlen (set_cmd_prefix
));
292 complete_nested_command_line (tracker
, new_text
.c_str ());
296 /* We're past the "--" delimiter. Complete on the sub command. */
297 const char *nested_cmd
= skip_spaces (delim
+ 2);
298 tracker
.advance_custom_word_point_by (nested_cmd
- text
);
299 complete_nested_command_line (tracker
, nested_cmd
);
302 /* The "with" command. */
305 with_command (const char *args
, int from_tty
)
307 with_command_1 ("set ", setlist
, args
, from_tty
);
310 /* "with" command completer. */
313 with_command_completer (struct cmd_list_element
*ignore
,
314 completion_tracker
&tracker
,
315 const char *text
, const char * /*word*/)
317 with_command_completer_1 ("set ", tracker
, text
);
320 /* Look up the contents of TEXT as a command usable with default args.
321 Throws an error if no such command is found.
322 Return the found command and advances TEXT past the found command.
323 If the found command is a postfix command, set *PREFIX_CMD to its
326 static struct cmd_list_element
*
327 lookup_cmd_for_default_args (const char **text
,
328 struct cmd_list_element
**prefix_cmd
)
330 const char *orig_text
= *text
;
331 struct cmd_list_element
*lcmd
;
333 if (*text
== nullptr || skip_spaces (*text
) == nullptr)
334 error (_("ALIAS missing."));
336 /* We first use lookup_cmd to verify TEXT unambiguously identifies
338 lcmd
= lookup_cmd (text
, cmdlist
, "", NULL
,
339 /*allow_unknown=*/ 0,
340 /*ignore_help_classes=*/ 1);
342 /* Note that we accept default args for prefix commands,
343 as a prefix command can also be a valid usable
344 command accepting some arguments.
345 For example, "thread apply" applies a command to a
346 list of thread ids, and is also the prefix command for
349 /* We have an unambiguous command for which default args
350 can be specified. What remains after having found LCMD
351 is either spaces, or the default args character. */
353 /* We then use lookup_cmd_composition to detect if the user
354 has specified an alias, and find the possible prefix_cmd
356 struct cmd_list_element
*alias
, *cmd
;
357 lookup_cmd_composition
358 (std::string (orig_text
, *text
- orig_text
).c_str (),
359 &alias
, prefix_cmd
, &cmd
);
360 gdb_assert (cmd
!= nullptr);
361 gdb_assert (cmd
== lcmd
);
362 if (alias
!= nullptr)
368 /* Provide documentation on command or list given by COMMAND. FROM_TTY
372 help_command (const char *command
, int from_tty
)
374 help_cmd (command
, gdb_stdout
);
378 /* Note: The "complete" command is used by Emacs to implement completion.
379 [Is that why this function writes output with *_unfiltered?] */
382 complete_command (const char *arg
, int from_tty
)
386 if (max_completions
== 0)
388 /* Only print this for non-mi frontends. An MI frontend may not
389 be able to handle this. */
390 if (!current_uiout
->is_mi_like_p ())
392 printf_unfiltered (_("max-completions is zero,"
393 " completion is disabled.\n"));
401 int quote_char
= '\0';
404 completion_result result
= complete (arg
, &word
, "e_char
);
406 if (result
.number_matches
!= 0)
408 std::string
arg_prefix (arg
, word
- arg
);
410 if (result
.number_matches
== 1)
411 printf_unfiltered ("%s%s\n", arg_prefix
.c_str (), result
.match_list
[0]);
414 result
.sort_match_list ();
416 for (size_t i
= 0; i
< result
.number_matches
; i
++)
418 printf_unfiltered ("%s%s",
420 result
.match_list
[i
+ 1]);
422 printf_unfiltered ("%c", quote_char
);
423 printf_unfiltered ("\n");
427 if (result
.number_matches
== max_completions
)
429 /* ARG_PREFIX and WORD are included in the output so that emacs
430 will include the message in the output. */
431 printf_unfiltered (_("%s%s %s\n"),
432 arg_prefix
.c_str (), word
,
433 get_max_completions_reached_message ());
439 is_complete_command (struct cmd_list_element
*c
)
441 return cmd_cfunc_eq (c
, complete_command
);
445 show_version (const char *args
, int from_tty
)
447 print_gdb_version (gdb_stdout
, true);
448 printf_filtered ("\n");
452 show_configuration (const char *args
, int from_tty
)
454 print_gdb_configuration (gdb_stdout
);
457 /* Handle the quit command. */
460 quit_command (const char *args
, int from_tty
)
464 /* An optional expression may be used to cause gdb to terminate with
465 the value of that expression. */
468 struct value
*val
= parse_and_eval (args
);
470 exit_code
= (int) value_as_long (val
);
473 if (!quit_confirm ())
474 error (_("Not confirmed."));
476 query_if_trace_running (from_tty
);
478 quit_force (args
? &exit_code
: NULL
, from_tty
);
482 pwd_command (const char *args
, int from_tty
)
485 error (_("The \"pwd\" command does not take an argument: %s"), args
);
487 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
490 error (_("Error finding name of working directory: %s"),
491 safe_strerror (errno
));
493 if (strcmp (cwd
.get (), current_directory
) != 0)
494 printf_unfiltered (_("Working directory %ps\n (canonically %ps).\n"),
495 styled_string (file_name_style
.style (),
497 styled_string (file_name_style
.style (), cwd
.get ()));
499 printf_unfiltered (_("Working directory %ps.\n"),
500 styled_string (file_name_style
.style (),
505 cd_command (const char *dir
, int from_tty
)
508 /* Found something other than leading repetitions of "/..". */
512 /* If the new directory is absolute, repeat is a no-op; if relative,
513 repeat might be useful but is more likely to be a mistake. */
516 gdb::unique_xmalloc_ptr
<char> dir_holder
517 (tilde_expand (dir
!= NULL
? dir
: "~"));
518 dir
= dir_holder
.get ();
521 perror_with_name (dir
);
523 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
524 /* There's too much mess with DOSish names like "d:", "d:.",
525 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
526 simply get the canonicalized name of the current directory. */
527 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
532 if (IS_DIR_SEPARATOR (dir
[len
- 1]))
534 /* Remove the trailing slash unless this is a root directory
535 (including a drive letter on non-Unix systems). */
536 if (!(len
== 1) /* "/" */
537 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
538 && !(len
== 3 && dir
[1] == ':') /* "d:/" */
544 dir_holder
.reset (savestring (dir
, len
));
545 if (IS_ABSOLUTE_PATH (dir_holder
.get ()))
547 xfree (current_directory
);
548 current_directory
= dir_holder
.release ();
552 if (IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1]))
553 current_directory
= concat (current_directory
, dir_holder
.get (),
556 current_directory
= concat (current_directory
, SLASH_STRING
,
557 dir_holder
.get (), (char *) NULL
);
560 /* Now simplify any occurrences of `.' and `..' in the pathname. */
563 for (p
= current_directory
; *p
;)
565 if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.'
566 && (p
[2] == 0 || IS_DIR_SEPARATOR (p
[2])))
567 memmove (p
, p
+ 2, strlen (p
+ 2) + 1);
568 else if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.' && p
[2] == '.'
569 && (p
[3] == 0 || IS_DIR_SEPARATOR (p
[3])))
573 /* Search backwards for the directory just before the "/.."
574 and obliterate it and the "/..". */
577 while (q
!= current_directory
&& !IS_DIR_SEPARATOR (q
[-1]))
580 if (q
== current_directory
)
581 /* current_directory is
582 a relative pathname ("can't happen"--leave it alone). */
586 memmove (q
- 1, p
+ 3, strlen (p
+ 3) + 1);
591 /* We are dealing with leading repetitions of "/..", for
592 example "/../..", which is the Mach super-root. */
602 forget_cached_source_info ();
605 pwd_command ((char *) 0, 1);
608 /* Show the current value of the 'script-extension' option. */
611 show_script_ext_mode (struct ui_file
*file
, int from_tty
,
612 struct cmd_list_element
*c
, const char *value
)
614 fprintf_filtered (file
,
615 _("Script filename extension recognition is \"%s\".\n"),
619 /* Try to open SCRIPT_FILE.
620 If successful, the full path name is stored in *FULL_PATHP,
621 and the stream is returned.
622 If not successful, return NULL; errno is set for the last file
625 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
626 search for it in the source search path. */
628 gdb::optional
<open_script
>
629 find_and_open_script (const char *script_file
, int search_path
)
632 openp_flags search_flags
= OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
;
633 gdb::optional
<open_script
> opened
;
635 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (script_file
));
638 search_flags
|= OPF_SEARCH_IN_PATH
;
640 /* Search for and open 'file' on the search path used for source
641 files. Put the full location in *FULL_PATHP. */
642 gdb::unique_xmalloc_ptr
<char> full_path
;
643 fd
= openp (source_path
, search_flags
,
644 file
.get (), O_RDONLY
, &full_path
);
649 FILE *result
= fdopen (fd
, FOPEN_RT
);
652 int save_errno
= errno
;
658 opened
.emplace (gdb_file_up (result
), std::move (full_path
));
663 /* Load script FILE, which has already been opened as STREAM.
664 FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
665 This is provided as FILE may have been found via the source search path.
666 An important thing to note here is that FILE may be a symlink to a file
667 with a different or non-existing suffix, and thus one cannot infer the
668 extension language from FILE_TO_OPEN. */
671 source_script_from_stream (FILE *stream
, const char *file
,
672 const char *file_to_open
)
674 if (script_ext_mode
!= script_ext_off
)
676 const struct extension_language_defn
*extlang
677 = get_ext_lang_of_file (file
);
681 if (ext_lang_present_p (extlang
))
683 script_sourcer_func
*sourcer
684 = ext_lang_script_sourcer (extlang
);
686 gdb_assert (sourcer
!= NULL
);
687 sourcer (extlang
, stream
, file_to_open
);
690 else if (script_ext_mode
== script_ext_soft
)
692 /* Assume the file is a gdb script.
693 This is handled below. */
696 throw_ext_lang_unsupported (extlang
);
700 script_from_file (stream
, file
);
703 /* Worker to perform the "source" command.
705 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
706 search for it in the source search path. */
709 source_script_with_search (const char *file
, int from_tty
, int search_path
)
712 if (file
== NULL
|| *file
== 0)
713 error (_("source command requires file name of file to source."));
715 gdb::optional
<open_script
> opened
= find_and_open_script (file
, search_path
);
718 /* The script wasn't found, or was otherwise inaccessible.
719 If the source command was invoked interactively, throw an
720 error. Otherwise (e.g. if it was invoked by a script),
721 just emit a warning, rather than cause an error. */
723 perror_with_name (file
);
726 perror_warning_with_name (file
);
731 /* The python support reopens the file, so we need to pass full_path here
732 in case the file was found on the search path. It's useful to do this
733 anyway so that error messages show the actual file used. But only do
734 this if we (may have) used search_path, as printing the full path in
735 errors for the non-search case can be more noise than signal. */
736 source_script_from_stream (opened
->stream
.get (), file
,
737 search_path
? opened
->full_path
.get () : file
);
740 /* Wrapper around source_script_with_search to export it to main.c
741 for use in loading .gdbinit scripts. */
744 source_script (const char *file
, int from_tty
)
746 source_script_with_search (file
, from_tty
, 0);
750 source_command (const char *args
, int from_tty
)
752 const char *file
= args
;
755 scoped_restore save_source_verbose
= make_scoped_restore (&source_verbose
);
757 /* -v causes the source command to run in verbose mode.
758 -s causes the file to be searched in the source search path,
759 even if the file name contains a '/'.
760 We still have to be able to handle filenames with spaces in a
761 backward compatible way, so buildargv is not appropriate. */
765 while (args
[0] != '\0')
767 /* Make sure leading white space does not break the
769 args
= skip_spaces (args
);
774 if (args
[1] == 'v' && isspace (args
[2]))
778 /* Skip passed -v. */
781 else if (args
[1] == 's' && isspace (args
[2]))
785 /* Skip passed -s. */
792 file
= skip_spaces (args
);
795 source_script_with_search (file
, from_tty
, search_path
);
800 echo_command (const char *text
, int from_tty
)
802 const char *p
= text
;
806 while ((c
= *p
++) != '\0')
810 /* \ at end of argument is used after spaces
811 so they won't be lost. */
815 c
= parse_escape (get_current_arch (), &p
);
817 printf_filtered ("%c", c
);
820 printf_filtered ("%c", c
);
823 reset_terminal_style (gdb_stdout
);
825 /* Force this output to appear now. */
827 gdb_flush (gdb_stdout
);
830 /* Sets the last launched shell command convenience variables based on
834 exit_status_set_internal_vars (int exit_status
)
836 struct internalvar
*var_code
= lookup_internalvar ("_shell_exitcode");
837 struct internalvar
*var_signal
= lookup_internalvar ("_shell_exitsignal");
839 clear_internalvar (var_code
);
840 clear_internalvar (var_signal
);
841 if (WIFEXITED (exit_status
))
842 set_internalvar_integer (var_code
, WEXITSTATUS (exit_status
));
844 else if (WIFSIGNALED (exit_status
) && WTERMSIG (exit_status
) == -1)
846 /* The -1 condition can happen on MinGW, if we don't recognize
847 the fatal exception code encoded in the exit status; see
848 gdbsupport/gdb_wait.c. We don't want to lose information in
849 the exit status in that case. Record it as a normal exit
850 with the full exit status, including the higher 0xC0000000
852 set_internalvar_integer (var_code
, exit_status
);
855 else if (WIFSIGNALED (exit_status
))
856 set_internalvar_integer (var_signal
, WTERMSIG (exit_status
));
858 warning (_("unexpected shell command exit status %d"), exit_status
);
862 shell_escape (const char *arg
, int from_tty
)
864 #if defined(CANT_FORK) || \
865 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
866 /* If ARG is NULL, they want an inferior shell, but `system' just
867 reports if the shell is available when passed a NULL arg. */
868 int rc
= system (arg
? arg
: "");
871 arg
= "inferior shell";
874 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
875 safe_strerror (errno
));
877 fprintf_unfiltered (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
879 /* Make sure to return to the directory GDB thinks it is, in case
880 the shell command we just ran changed it. */
881 chdir (current_directory
);
883 exit_status_set_internal_vars (rc
);
884 #else /* Can fork. */
887 if ((pid
= vfork ()) == 0)
889 const char *p
, *user_shell
= get_shell ();
893 /* Get the name of the shell for arg0. */
894 p
= lbasename (user_shell
);
897 execl (user_shell
, p
, (char *) 0);
899 execl (user_shell
, p
, "-c", arg
, (char *) 0);
901 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
902 safe_strerror (errno
));
907 waitpid (pid
, &status
, 0);
909 error (_("Fork failed"));
910 exit_status_set_internal_vars (status
);
911 #endif /* Can fork. */
914 /* Implementation of the "shell" command. */
917 shell_command (const char *arg
, int from_tty
)
919 shell_escape (arg
, from_tty
);
923 edit_command (const char *arg
, int from_tty
)
925 struct symtab_and_line sal
;
931 /* Pull in the current default source line if necessary. */
934 set_default_source_symtab_and_line ();
935 sal
= get_current_source_symtab_and_line ();
938 /* Bare "edit" edits file with present line. */
943 error (_("No default source file yet."));
944 sal
.line
+= get_lines_to_list () / 2;
950 /* Now should only be one argument -- decode it in SAL. */
952 event_location_up location
= string_to_event_location (&arg1
,
954 std::vector
<symtab_and_line
> sals
= decode_line_1 (location
.get (),
955 DECODE_LINE_LIST_MODE
,
964 if (sals
.size () > 1)
966 ambiguous_line_spec (sals
,
967 _("Specified line is ambiguous:\n"));
974 error (_("Junk at end of line specification."));
976 /* If line was specified by address, first print exactly which
977 line, and which file. In this case, sal.symtab == 0 means
978 address is outside of all known source files, not that user
979 failed to give a filename. */
982 struct gdbarch
*gdbarch
;
985 error (_("No source file for address %s."),
986 paddress (get_current_arch (), sal
.pc
));
988 gdbarch
= SYMTAB_OBJFILE (sal
.symtab
)->arch ();
989 sym
= find_pc_function (sal
.pc
);
991 printf_filtered ("%s is in %s (%s:%d).\n",
992 paddress (gdbarch
, sal
.pc
),
994 symtab_to_filename_for_display (sal
.symtab
),
997 printf_filtered ("%s is at %s:%d.\n",
998 paddress (gdbarch
, sal
.pc
),
999 symtab_to_filename_for_display (sal
.symtab
),
1003 /* If what was given does not imply a symtab, it must be an
1004 undebuggable symbol which means no source code. */
1006 if (sal
.symtab
== 0)
1007 error (_("No line number known for %s."), arg
);
1010 if ((editor
= getenv ("EDITOR")) == NULL
)
1013 fn
= symtab_to_fullname (sal
.symtab
);
1015 /* Quote the file name, in case it has whitespace or other special
1017 p
= xstrprintf ("%s +%d \"%s\"", editor
, sal
.line
, fn
);
1018 shell_escape (p
, from_tty
);
1022 /* The options for the "pipe" command. */
1024 struct pipe_cmd_opts
1027 char *delimiter
= nullptr;
1035 static const gdb::option::option_def pipe_cmd_option_defs
[] = {
1037 gdb::option::string_option_def
<pipe_cmd_opts
> {
1039 [] (pipe_cmd_opts
*opts
) { return &opts
->delimiter
; },
1041 N_("Indicates to use the specified delimiter string to separate\n\
1042 COMMAND from SHELL_COMMAND, in alternative to |. This is useful in\n\
1043 case COMMAND contains a | character."),
1048 /* Create an option_def_group for the "pipe" command's options, with
1051 static inline gdb::option::option_def_group
1052 make_pipe_cmd_options_def_group (pipe_cmd_opts
*opts
)
1054 return {{pipe_cmd_option_defs
}, opts
};
1057 /* Implementation of the "pipe" command. */
1060 pipe_command (const char *arg
, int from_tty
)
1064 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1065 gdb::option::process_options
1066 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
1068 const char *delim
= "|";
1069 if (opts
.delimiter
!= nullptr)
1070 delim
= opts
.delimiter
;
1072 const char *command
= arg
;
1073 if (command
== nullptr)
1074 error (_("Missing COMMAND"));
1076 arg
= strstr (arg
, delim
);
1079 error (_("Missing delimiter before SHELL_COMMAND"));
1081 std::string
gdb_cmd (command
, arg
- command
);
1083 arg
+= strlen (delim
); /* Skip the delimiter. */
1085 if (gdb_cmd
.empty ())
1086 gdb_cmd
= repeat_previous ();
1088 const char *shell_command
= skip_spaces (arg
);
1089 if (*shell_command
== '\0')
1090 error (_("Missing SHELL_COMMAND"));
1092 FILE *to_shell_command
= popen (shell_command
, "w");
1094 if (to_shell_command
== nullptr)
1095 error (_("Error launching \"%s\""), shell_command
);
1099 stdio_file
pipe_file (to_shell_command
);
1101 execute_command_to_ui_file (&pipe_file
, gdb_cmd
.c_str (), from_tty
);
1105 pclose (to_shell_command
);
1109 int exit_status
= pclose (to_shell_command
);
1111 if (exit_status
< 0)
1112 error (_("shell command \"%s\" failed: %s"), shell_command
,
1113 safe_strerror (errno
));
1114 exit_status_set_internal_vars (exit_status
);
1117 /* Completer for the pipe command. */
1120 pipe_command_completer (struct cmd_list_element
*ignore
,
1121 completion_tracker
&tracker
,
1122 const char *text
, const char *word_ignored
)
1126 const char *org_text
= text
;
1127 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1128 if (gdb::option::complete_options
1129 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
))
1132 const char *delimiter
= "|";
1133 if (opts
.delimiter
!= nullptr)
1134 delimiter
= opts
.delimiter
;
1136 /* Check if we're past option values already. */
1137 if (text
> org_text
&& !isspace (text
[-1]))
1140 const char *delim
= strstr (text
, delimiter
);
1142 /* If we're still not past the delimiter, complete the gdb
1144 if (delim
== nullptr || delim
== text
)
1146 complete_nested_command_line (tracker
, text
);
1150 /* We're past the delimiter. What follows is a shell command, which
1151 we don't know how to complete. */
1155 list_command (const char *arg
, int from_tty
)
1162 int linenum_beg
= 0;
1165 /* Pull in the current default source line if necessary. */
1166 if (arg
== NULL
|| ((arg
[0] == '+' || arg
[0] == '-') && arg
[1] == '\0'))
1168 set_default_source_symtab_and_line ();
1169 symtab_and_line cursal
= get_current_source_symtab_and_line ();
1171 /* If this is the first "list" since we've set the current
1172 source line, center the listing around that line. */
1173 if (get_first_line_listed () == 0)
1177 first
= std::max (cursal
.line
- get_lines_to_list () / 2, 1);
1179 /* A small special case --- if listing backwards, and we
1180 should list only one line, list the preceding line,
1181 instead of the exact line we've just shown after e.g.,
1182 stopping for a breakpoint. */
1183 if (arg
!= NULL
&& arg
[0] == '-'
1184 && get_lines_to_list () == 1 && first
> 1)
1187 print_source_lines (cursal
.symtab
, source_lines_range (first
), 0);
1190 /* "l" or "l +" lists next ten lines. */
1191 else if (arg
== NULL
|| arg
[0] == '+')
1192 print_source_lines (cursal
.symtab
,
1193 source_lines_range (cursal
.line
), 0);
1195 /* "l -" lists previous ten lines, the ones before the ten just
1197 else if (arg
[0] == '-')
1199 if (get_first_line_listed () == 1)
1200 error (_("Already at the start of %s."),
1201 symtab_to_filename_for_display (cursal
.symtab
));
1202 source_lines_range
range (get_first_line_listed (),
1203 source_lines_range::BACKWARD
);
1204 print_source_lines (cursal
.symtab
, range
, 0);
1210 /* Now if there is only one argument, decode it in SAL
1212 If there are two arguments, decode them in SAL and SAL_END
1213 and clear NO_END; however, if one of the arguments is blank,
1214 set DUMMY_BEG or DUMMY_END to record that fact. */
1216 if (!have_full_symbols () && !have_partial_symbols ())
1217 error (_("No symbol table is loaded. Use the \"file\" command."));
1219 std::vector
<symtab_and_line
> sals
;
1220 symtab_and_line sal
, sal_end
;
1227 event_location_up location
= string_to_event_location (&arg1
,
1229 sals
= decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1241 /* Record whether the BEG arg is all digits. */
1243 for (p
= arg
; p
!= arg1
&& *p
>= '0' && *p
<= '9'; p
++);
1244 linenum_beg
= (p
== arg1
);
1246 /* Save the range of the first argument, in case we need to let the
1247 user know it was ambiguous. */
1248 const char *beg
= arg
;
1249 size_t beg_len
= arg1
- beg
;
1251 while (*arg1
== ' ' || *arg1
== '\t')
1256 if (sals
.size () > 1)
1258 ambiguous_line_spec (sals
,
1259 _("Specified first line '%.*s' is ambiguous:\n"),
1260 (int) beg_len
, beg
);
1264 while (*arg1
== ' ' || *arg1
== '\t')
1270 /* Save the last argument, in case we need to let the user
1271 know it was ambiguous. */
1272 const char *end_arg
= arg1
;
1274 event_location_up location
1275 = string_to_event_location (&arg1
, current_language
);
1277 std::vector
<symtab_and_line
> sals_end
1279 ? decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1281 : decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1282 NULL
, sal
.symtab
, sal
.line
));
1284 filter_sals (sals_end
);
1285 if (sals_end
.empty ())
1287 if (sals_end
.size () > 1)
1289 ambiguous_line_spec (sals_end
,
1290 _("Specified last line '%s' is ambiguous:\n"),
1294 sal_end
= sals_end
[0];
1299 error (_("Junk at end of line specification."));
1301 if (!no_end
&& !dummy_beg
&& !dummy_end
1302 && sal
.symtab
!= sal_end
.symtab
)
1303 error (_("Specified first and last lines are in different files."));
1304 if (dummy_beg
&& dummy_end
)
1305 error (_("Two empty args do not say what lines to list."));
1307 /* If line was specified by address,
1308 first print exactly which line, and which file.
1310 In this case, sal.symtab == 0 means address is outside of all
1311 known source files, not that user failed to give a filename. */
1314 struct gdbarch
*gdbarch
;
1316 if (sal
.symtab
== 0)
1317 error (_("No source file for address %s."),
1318 paddress (get_current_arch (), sal
.pc
));
1320 gdbarch
= SYMTAB_OBJFILE (sal
.symtab
)->arch ();
1321 sym
= find_pc_function (sal
.pc
);
1323 printf_filtered ("%s is in %s (%s:%d).\n",
1324 paddress (gdbarch
, sal
.pc
),
1326 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1328 printf_filtered ("%s is at %s:%d.\n",
1329 paddress (gdbarch
, sal
.pc
),
1330 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1333 /* If line was not specified by just a line number, and it does not
1334 imply a symtab, it must be an undebuggable symbol which means no
1337 if (!linenum_beg
&& sal
.symtab
== 0)
1338 error (_("No line number known for %s."), arg
);
1340 /* If this command is repeated with RET,
1341 turn it into the no-arg variant. */
1344 set_repeat_arguments ("");
1346 if (dummy_beg
&& sal_end
.symtab
== 0)
1347 error (_("No default source file yet. Do \"help list\"."));
1350 source_lines_range
range (sal_end
.line
+ 1,
1351 source_lines_range::BACKWARD
);
1352 print_source_lines (sal_end
.symtab
, range
, 0);
1354 else if (sal
.symtab
== 0)
1355 error (_("No default source file yet. Do \"help list\"."));
1358 for (int i
= 0; i
< sals
.size (); i
++)
1361 int first_line
= sal
.line
- get_lines_to_list () / 2;
1364 if (sals
.size () > 1)
1365 print_sal_location (sal
);
1366 print_source_lines (sal
.symtab
, source_lines_range (first_line
), 0);
1370 print_source_lines (sal
.symtab
, source_lines_range (sal
.line
), 0);
1372 print_source_lines (sal
.symtab
,
1373 source_lines_range (sal
.line
, (sal_end
.line
+ 1)),
1377 /* Subroutine of disassemble_command to simplify it.
1378 Perform the disassembly.
1379 NAME is the name of the function if known, or NULL.
1380 [LOW,HIGH) are the range of addresses to disassemble.
1381 BLOCK is the block to disassemble; it needs to be provided
1382 when non-contiguous blocks are disassembled; otherwise
1384 MIXED is non-zero to print source with the assembler. */
1387 print_disassembly (struct gdbarch
*gdbarch
, const char *name
,
1388 CORE_ADDR low
, CORE_ADDR high
,
1389 const struct block
*block
,
1390 gdb_disassembly_flags flags
)
1393 if (tui_is_window_visible (DISASSEM_WIN
))
1394 tui_show_assembly (gdbarch
, low
);
1398 printf_filtered ("Dump of assembler code ");
1400 printf_filtered ("for function %s:\n", name
);
1401 if (block
== nullptr || BLOCK_CONTIGUOUS_P (block
))
1404 printf_filtered ("from %s to %s:\n",
1405 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
1407 /* Dump the specified range. */
1408 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1, low
, high
);
1412 for (int i
= 0; i
< BLOCK_NRANGES (block
); i
++)
1414 CORE_ADDR range_low
= BLOCK_RANGE_START (block
, i
);
1415 CORE_ADDR range_high
= BLOCK_RANGE_END (block
, i
);
1416 printf_filtered (_("Address range %s to %s:\n"),
1417 paddress (gdbarch
, range_low
),
1418 paddress (gdbarch
, range_high
));
1419 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1,
1420 range_low
, range_high
);
1423 printf_filtered ("End of assembler dump.\n");
1427 /* Subroutine of disassemble_command to simplify it.
1428 Print a disassembly of the current function according to FLAGS. */
1431 disassemble_current_function (gdb_disassembly_flags flags
)
1433 struct frame_info
*frame
;
1434 struct gdbarch
*gdbarch
;
1435 CORE_ADDR low
, high
, pc
;
1437 const struct block
*block
;
1439 frame
= get_selected_frame (_("No frame selected."));
1440 gdbarch
= get_frame_arch (frame
);
1441 pc
= get_frame_address_in_block (frame
);
1442 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1443 error (_("No function contains program counter for selected frame."));
1445 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1448 /* FIXME: cagney/2004-02-07: This should be an observer. */
1449 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1451 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1453 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1456 /* Dump a specified section of assembly code.
1460 - dump the assembly code for the function of the current pc
1461 disassemble [/mrs] addr
1462 - dump the assembly code for the function at ADDR
1463 disassemble [/mrs] low,high
1464 disassemble [/mrs] low,+length
1465 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1467 A /m modifier will include source code with the assembly in a
1468 "source centric" view. This view lists only the file of the first insn,
1469 even if other source files are involved (e.g., inlined functions), and
1470 the output is in source order, even with optimized code. This view is
1471 considered deprecated as it hasn't been useful in practice.
1473 A /r modifier will include raw instructions in hex with the assembly.
1475 A /s modifier will include source code with the assembly, like /m, with
1476 two important differences:
1477 1) The output is still in pc address order.
1478 2) File names and contents for all relevant source files are displayed. */
1481 disassemble_command (const char *arg
, int from_tty
)
1483 struct gdbarch
*gdbarch
= get_current_arch ();
1484 CORE_ADDR low
, high
;
1487 gdb_disassembly_flags flags
;
1489 const struct block
*block
= nullptr;
1500 error (_("Missing modifier."));
1502 while (*p
&& ! isspace (*p
))
1507 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1510 flags
|= DISASSEMBLY_RAW_INSN
;
1513 flags
|= DISASSEMBLY_SOURCE
;
1516 error (_("Invalid disassembly modifier."));
1520 p
= skip_spaces (p
);
1523 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1524 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1525 error (_("Cannot specify both /m and /s."));
1529 flags
|= DISASSEMBLY_OMIT_FNAME
;
1530 disassemble_current_function (flags
);
1534 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1540 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1541 error (_("No function contains specified address."));
1543 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1546 /* FIXME: cagney/2004-02-07: This should be an observer. */
1547 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1549 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1550 flags
|= DISASSEMBLY_OMIT_FNAME
;
1554 /* Two arguments. */
1557 p
= skip_spaces (p
);
1563 high
= parse_and_eval_address (p
);
1568 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1572 make_command (const char *arg
, int from_tty
)
1575 shell_escape ("make", from_tty
);
1578 std::string cmd
= std::string ("make ") + arg
;
1580 shell_escape (cmd
.c_str (), from_tty
);
1585 show_user (const char *args
, int from_tty
)
1587 struct cmd_list_element
*c
;
1591 const char *comname
= args
;
1593 c
= lookup_cmd (&comname
, cmdlist
, "", NULL
, 0, 1);
1594 if (!cli_user_command_p (c
))
1595 error (_("Not a user command."));
1596 show_user_1 (c
, "", args
, gdb_stdout
);
1600 for (c
= cmdlist
; c
; c
= c
->next
)
1602 if (cli_user_command_p (c
) || c
->prefixlist
!= NULL
)
1603 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1608 /* Search through names of commands and documentations for a certain
1609 regular expression. */
1612 apropos_command (const char *arg
, int from_tty
)
1614 bool verbose
= arg
&& check_for_argument (&arg
, "-v", 2);
1616 if (arg
== NULL
|| *arg
== '\0')
1617 error (_("REGEXP string is empty"));
1619 compiled_regex
pattern (arg
, REG_ICASE
,
1620 _("Error in regular expression"));
1622 apropos_cmd (gdb_stdout
, cmdlist
, verbose
, pattern
, "");
1625 /* The options for the "alias" command. */
1630 bool abbrev_flag
= false;
1633 static const gdb::option::option_def alias_option_defs
[] = {
1635 gdb::option::flag_option_def
<alias_opts
> {
1637 [] (alias_opts
*opts
) { return &opts
->abbrev_flag
; },
1638 N_("Specify that ALIAS is an abbreviation of COMMAND.\n\
1639 Abbreviations are not used in command completion."),
1644 /* Create an option_def_group for the "alias" options, with
1645 A_OPTS as context. */
1647 static gdb::option::option_def_group
1648 make_alias_options_def_group (alias_opts
*a_opts
)
1650 return {{alias_option_defs
}, a_opts
};
1653 /* Completer for the "alias_command". */
1656 alias_command_completer (struct cmd_list_element
*ignore
,
1657 completion_tracker
&tracker
,
1658 const char *text
, const char *word
)
1660 const auto grp
= make_alias_options_def_group (nullptr);
1662 tracker
.set_use_custom_word_point (true);
1664 if (gdb::option::complete_options
1665 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
))
1668 const char *delim
= strchr (text
, '=');
1670 /* If we're past the "=" delimiter, complete the
1671 "alias ALIAS = COMMAND [DEFAULT-ARGS...]" as if the user is
1672 typing COMMAND DEFAULT-ARGS... */
1675 && isspace (delim
[-1])
1676 && (isspace (delim
[1]) || delim
[1] == '\0'))
1678 std::string new_text
= std::string (delim
+ 1);
1680 tracker
.advance_custom_word_point_by (delim
+ 1 - text
);
1681 complete_nested_command_line (tracker
, new_text
.c_str ());
1685 /* We're not yet past the "=" delimiter. Complete a command, as
1686 the user might type an alias following a prefix command. */
1687 complete_nested_command_line (tracker
, text
);
1690 /* Subroutine of alias_command to simplify it.
1691 Return the first N elements of ARGV flattened back to a string
1692 with a space separating each element.
1693 ARGV may not be NULL.
1694 This does not take care of quoting elements in case they contain spaces
1698 argv_to_string (char **argv
, int n
)
1703 gdb_assert (argv
!= NULL
);
1704 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1706 for (i
= 0; i
< n
; ++i
)
1716 /* Subroutine of alias_command to simplify it.
1717 Verifies that COMMAND can have an alias:
1719 COMMAND must not have default args.
1720 This last condition is to avoid the following:
1721 alias aaa = backtrace -full
1722 alias bbb = aaa -past-main
1723 as (at least currently), alias default args are not cumulative
1724 and the user would expect bbb to execute 'backtrace -full -past-main'
1725 while it will execute 'backtrace -past-main'. */
1728 validate_aliased_command (const char *command
)
1730 struct cmd_list_element
*c
;
1731 std::string default_args
;
1733 c
= lookup_cmd_1 (& command
, cmdlist
, NULL
, &default_args
, 1);
1735 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1736 error (_("Invalid command to alias to: %s"), command
);
1738 if (!default_args
.empty ())
1739 error (_("Cannot define an alias of an alias that has default args"));
1742 /* Called when "alias" was incorrectly used. */
1745 alias_usage_error (void)
1747 error (_("Usage: alias [-a] [--] ALIAS = COMMAND [DEFAULT-ARGS...]"));
1750 /* Make an alias of an existing command. */
1753 alias_command (const char *args
, int from_tty
)
1757 auto grp
= make_alias_options_def_group (&a_opts
);
1758 gdb::option::process_options
1759 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
);
1761 int i
, alias_argc
, command_argc
;
1763 const char *alias
, *command
;
1765 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1766 alias_usage_error ();
1768 equals
= strchr (args
, '=');
1769 std::string
args2 (args
, equals
- args
);
1771 gdb_argv
built_alias_argv (args2
.c_str ());
1773 const char *default_args
= equals
+ 1;
1774 struct cmd_list_element
*c_command_prefix
;
1776 lookup_cmd_for_default_args (&default_args
, &c_command_prefix
);
1777 std::string
command_argv_str (equals
+ 1,
1778 default_args
== nullptr
1779 ? strlen (equals
+ 1)
1780 : default_args
- equals
- 1);
1781 gdb_argv
command_argv (command_argv_str
.c_str ());
1783 char **alias_argv
= built_alias_argv
.get ();
1785 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1786 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1787 alias_usage_error ();
1789 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1791 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1794 error (_("Invalid command name: %s"), alias_argv
[i
]);
1796 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1800 alias_argc
= countargv (alias_argv
);
1801 command_argc
= command_argv
.count ();
1803 /* COMMAND must exist, and cannot have default args.
1804 Reconstruct the command to remove any extraneous spaces,
1805 for better error messages. */
1806 std::string
command_string (argv_to_string (command_argv
.get (),
1808 command
= command_string
.c_str ();
1809 validate_aliased_command (command
);
1811 /* ALIAS must not exist. */
1812 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1813 alias
= alias_string
.c_str ();
1815 cmd_list_element
*alias_cmd
, *prefix_cmd
, *cmd
;
1817 if (lookup_cmd_composition (alias
, &alias_cmd
, &prefix_cmd
, &cmd
))
1819 const char *alias_name
= alias_argv
[alias_argc
-1];
1821 /* If we found an existing ALIAS_CMD, check that the prefix differ or
1824 if (alias_cmd
!= nullptr
1825 && alias_cmd
->prefix
== prefix_cmd
1826 && strcmp (alias_name
, alias_cmd
->name
) == 0)
1827 error (_("Alias already exists: %s"), alias
);
1829 /* Check ALIAS differs from the found CMD. */
1831 if (cmd
->prefix
== prefix_cmd
1832 && strcmp (alias_name
, cmd
->name
) == 0)
1833 error (_("Alias %s is the name of an existing command"), alias
);
1838 struct cmd_list_element
*alias_cmd
;
1840 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1841 Example: alias spe = set print elements
1843 Otherwise ALIAS and COMMAND must have the same number of words,
1844 and every word except the last must identify the same prefix command;
1845 and the last word of ALIAS is made an alias of the last word of COMMAND.
1846 Example: alias set print elms = set pr elem
1847 Note that unambiguous abbreviations are allowed. */
1849 if (alias_argc
== 1)
1851 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1852 alias_cmd
= add_com_alias (xstrdup (alias_argv
[0]), command
, class_alias
,
1853 a_opts
.abbrev_flag
);
1857 const char *alias_prefix
, *command_prefix
;
1858 struct cmd_list_element
*c_alias
, *c_command
;
1860 if (alias_argc
!= command_argc
)
1861 error (_("Mismatched command length between ALIAS and COMMAND."));
1863 /* Create copies of ALIAS and COMMAND without the last word,
1864 and use that to verify the leading elements give the same
1866 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1868 std::string
command_prefix_string (argv_to_string (command_argv
.get (),
1870 alias_prefix
= alias_prefix_string
.c_str ();
1871 command_prefix
= command_prefix_string
.c_str ();
1873 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, NULL
, 1);
1874 /* We've already tried to look up COMMAND. */
1875 gdb_assert (c_command
!= NULL
1876 && c_command
!= (struct cmd_list_element
*) -1);
1877 gdb_assert (c_command
->prefixlist
!= NULL
);
1878 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, NULL
, 1);
1879 if (c_alias
!= c_command
)
1880 error (_("ALIAS and COMMAND prefixes do not match."));
1882 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1883 alias_cmd
= add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1884 command_argv
[command_argc
- 1],
1885 class_alias
, a_opts
.abbrev_flag
,
1886 c_command
->prefixlist
);
1889 gdb_assert (alias_cmd
!= nullptr);
1890 gdb_assert (alias_cmd
->default_args
.empty ());
1891 if (default_args
!= nullptr)
1893 default_args
= skip_spaces (default_args
);
1895 alias_cmd
->default_args
= default_args
;
1899 /* Print the file / line number / symbol name of the location
1900 specified by SAL. */
1903 print_sal_location (const symtab_and_line
&sal
)
1905 scoped_restore_current_program_space restore_pspace
;
1906 set_current_program_space (sal
.pspace
);
1908 const char *sym_name
= NULL
;
1909 if (sal
.symbol
!= NULL
)
1910 sym_name
= sal
.symbol
->print_name ();
1911 printf_filtered (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
1912 symtab_to_filename_for_display (sal
.symtab
),
1913 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
1916 /* Print a list of files and line numbers which a user may choose from
1917 in order to list a function which was specified ambiguously (as
1918 with `list classname::overloadedfuncname', for example). The SALS
1919 array provides the filenames and line numbers. FORMAT is a
1920 printf-style format string used to tell the user what was
1924 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
1925 const char *format
, ...)
1928 va_start (ap
, format
);
1929 vprintf_filtered (format
, ap
);
1932 for (const auto &sal
: sals
)
1933 print_sal_location (sal
);
1936 /* Comparison function for filter_sals. Returns a qsort-style
1940 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1942 const char *dira
= SYMTAB_DIRNAME (sala
.symtab
);
1943 const char *dirb
= SYMTAB_DIRNAME (salb
.symtab
);
1951 else if (dirb
== NULL
)
1958 r
= filename_cmp (dira
, dirb
);
1963 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
1967 if (sala
.line
< salb
.line
)
1969 return sala
.line
== salb
.line
? 0 : 1;
1972 /* Remove any SALs that do not match the current program space, or
1973 which appear to be "file:line" duplicates. */
1976 filter_sals (std::vector
<symtab_and_line
> &sals
)
1978 /* Remove SALs that do not match. */
1979 auto from
= std::remove_if (sals
.begin (), sals
.end (),
1980 [&] (const symtab_and_line
&sal
)
1981 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
1984 std::sort (sals
.begin (), from
,
1985 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1986 { return cmp_symtabs (sala
, salb
) < 0; });
1988 from
= std::unique (sals
.begin (), from
,
1989 [&] (const symtab_and_line
&sala
,
1990 const symtab_and_line
&salb
)
1991 { return cmp_symtabs (sala
, salb
) == 0; });
1993 sals
.erase (from
, sals
.end ());
1997 init_cmd_lists (void)
1999 max_user_call_depth
= 1024;
2003 show_info_verbose (struct ui_file
*file
, int from_tty
,
2004 struct cmd_list_element
*c
,
2008 fprintf_filtered (file
,
2009 _("Verbose printing of informational messages is %s.\n"),
2012 fprintf_filtered (file
, _("Verbosity is %s.\n"), value
);
2016 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
2017 struct cmd_list_element
*c
, const char *value
)
2019 fprintf_filtered (file
, _("History expansion on command input is %s.\n"),
2024 show_remote_debug (struct ui_file
*file
, int from_tty
,
2025 struct cmd_list_element
*c
, const char *value
)
2027 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
2032 show_remote_timeout (struct ui_file
*file
, int from_tty
,
2033 struct cmd_list_element
*c
, const char *value
)
2035 fprintf_filtered (file
,
2036 _("Timeout limit to wait for target to respond is %s.\n"),
2041 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
2042 struct cmd_list_element
*c
, const char *value
)
2044 fprintf_filtered (file
,
2045 _("The max call depth for user-defined commands is %s.\n"),
2049 /* Returns the cmd_list_element in SHOWLIST corresponding to the first
2050 argument of ARGV, which must contain one single value.
2051 Throws an error if no value provided, or value not correct.
2052 FNNAME is used in the error message. */
2054 static cmd_list_element
*
2055 setting_cmd (const char *fnname
, struct cmd_list_element
*showlist
,
2056 int argc
, struct value
**argv
)
2059 error (_("You must provide an argument to %s"), fnname
);
2061 error (_("You can only provide one argument to %s"), fnname
);
2063 struct type
*type0
= check_typedef (value_type (argv
[0]));
2065 if (type0
->code () != TYPE_CODE_ARRAY
2066 && type0
->code () != TYPE_CODE_STRING
)
2067 error (_("First argument of %s must be a string."), fnname
);
2069 const char *a0
= (const char *) value_contents (argv
[0]);
2070 cmd_list_element
*cmd
= lookup_cmd (&a0
, showlist
, "", NULL
, -1, 0);
2072 if (cmd
== nullptr || cmd_type (cmd
) != show_cmd
)
2073 error (_("First argument of %s must be a "
2074 "valid setting of the 'show' command."), fnname
);
2079 /* Builds a value from the show CMD. */
2081 static struct value
*
2082 value_from_setting (const cmd_list_element
*cmd
, struct gdbarch
*gdbarch
)
2084 switch (cmd
->var_type
)
2087 if (*(int *) cmd
->var
== INT_MAX
)
2088 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2091 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2094 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2097 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2098 *(bool *) cmd
->var
? 1 : 0);
2099 case var_zuinteger_unlimited
:
2100 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2102 case var_auto_boolean
:
2106 switch (*(enum auto_boolean
*) cmd
->var
)
2108 case AUTO_BOOLEAN_TRUE
:
2111 case AUTO_BOOLEAN_FALSE
:
2114 case AUTO_BOOLEAN_AUTO
:
2118 gdb_assert_not_reached ("invalid var_auto_boolean");
2120 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2124 if (*(unsigned int *) cmd
->var
== UINT_MAX
)
2125 return value_from_ulongest
2126 (builtin_type (gdbarch
)->builtin_unsigned_int
, 0);
2128 return value_from_ulongest
2129 (builtin_type (gdbarch
)->builtin_unsigned_int
,
2130 *(unsigned int *) cmd
->var
);
2132 return value_from_ulongest (builtin_type (gdbarch
)->builtin_unsigned_int
,
2133 *(unsigned int *) cmd
->var
);
2135 case var_string_noescape
:
2136 case var_optional_filename
:
2139 if (*(char **) cmd
->var
)
2140 return value_cstring (*(char **) cmd
->var
, strlen (*(char **) cmd
->var
),
2141 builtin_type (gdbarch
)->builtin_char
);
2143 return value_cstring ("", 1,
2144 builtin_type (gdbarch
)->builtin_char
);
2146 gdb_assert_not_reached ("bad var_type");
2150 /* Implementation of the convenience function $_gdb_setting. */
2152 static struct value
*
2153 gdb_setting_internal_fn (struct gdbarch
*gdbarch
,
2154 const struct language_defn
*language
,
2155 void *cookie
, int argc
, struct value
**argv
)
2157 return value_from_setting (setting_cmd ("$_gdb_setting", showlist
,
2162 /* Implementation of the convenience function $_gdb_maint_setting. */
2164 static struct value
*
2165 gdb_maint_setting_internal_fn (struct gdbarch
*gdbarch
,
2166 const struct language_defn
*language
,
2167 void *cookie
, int argc
, struct value
**argv
)
2169 return value_from_setting (setting_cmd ("$_gdb_maint_setting",
2170 maintenance_show_cmdlist
,
2175 /* Builds a string value from the show CMD. */
2177 static struct value
*
2178 str_value_from_setting (const cmd_list_element
*cmd
, struct gdbarch
*gdbarch
)
2180 switch (cmd
->var_type
)
2185 case var_zuinteger_unlimited
:
2186 case var_auto_boolean
:
2190 std::string cmd_val
= get_setshow_command_value_string (cmd
);
2192 return value_cstring (cmd_val
.c_str (), cmd_val
.size (),
2193 builtin_type (gdbarch
)->builtin_char
);
2197 case var_string_noescape
:
2198 case var_optional_filename
:
2201 /* For these cases, we do not use get_setshow_command_value_string,
2202 as this function handle some characters specially, e.g. by
2203 escaping quotes. So, we directly use the cmd->var string value,
2204 similarly to the value_from_setting code for these cases. */
2205 if (*(char **) cmd
->var
)
2206 return value_cstring (*(char **) cmd
->var
, strlen (*(char **) cmd
->var
),
2207 builtin_type (gdbarch
)->builtin_char
);
2209 return value_cstring ("", 1,
2210 builtin_type (gdbarch
)->builtin_char
);
2213 gdb_assert_not_reached ("bad var_type");
2217 /* Implementation of the convenience function $_gdb_setting_str. */
2219 static struct value
*
2220 gdb_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2221 const struct language_defn
*language
,
2222 void *cookie
, int argc
, struct value
**argv
)
2224 return str_value_from_setting (setting_cmd ("$_gdb_setting_str",
2225 showlist
, argc
, argv
),
2230 /* Implementation of the convenience function $_gdb_maint_setting_str. */
2232 static struct value
*
2233 gdb_maint_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2234 const struct language_defn
*language
,
2235 void *cookie
, int argc
, struct value
**argv
)
2237 return str_value_from_setting (setting_cmd ("$_gdb_maint_setting_str",
2238 maintenance_show_cmdlist
,
2243 void _initialize_cli_cmds ();
2245 _initialize_cli_cmds ()
2247 struct cmd_list_element
*c
;
2249 /* Define the classes of commands.
2250 They will appear in the help list in alphabetical order. */
2252 add_cmd ("internals", class_maintenance
, _("\
2253 Maintenance commands.\n\
2254 Some gdb commands are provided just for use by gdb maintainers.\n\
2255 These commands are subject to frequent change, and may not be as\n\
2256 well documented as user commands."),
2258 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
2259 add_cmd ("aliases", class_alias
,
2260 _("User-defined aliases of other commands."), &cmdlist
);
2261 add_cmd ("user-defined", class_user
, _("\
2262 User-defined commands.\n\
2263 The commands in this class are those defined by the user.\n\
2264 Use the \"define\" command to define a command."), &cmdlist
);
2265 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
2267 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
2268 add_cmd ("files", class_files
, _("Specifying and examining files."),
2270 add_cmd ("breakpoints", class_breakpoint
,
2271 _("Making program stop at certain points."), &cmdlist
);
2272 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
2273 add_cmd ("stack", class_stack
, _("\
2274 Examining the stack.\n\
2275 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
2276 counting from zero for the innermost (currently executing) frame.\n\n\
2277 At any time gdb identifies one frame as the \"selected\" frame.\n\
2278 Variable lookups are done with respect to the selected frame.\n\
2279 When the program being debugged stops, gdb selects the innermost frame.\n\
2280 The commands below can be used to select other frames by number or address."),
2283 add_cmd ("text-user-interface", class_tui
,
2284 _("TUI is the GDB text based interface.\n\
2285 In TUI mode, GDB can display several text windows showing\n\
2286 the source file, the processor registers, the program disassembly, ..."), &cmdlist
);
2288 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
2290 /* Define general commands. */
2292 add_com ("pwd", class_files
, pwd_command
, _("\
2293 Print working directory.\n\
2294 This is used for your program as well."));
2296 c
= add_cmd ("cd", class_files
, cd_command
, _("\
2297 Set working directory to DIR for debugger.\n\
2298 The debugger's current working directory specifies where scripts and other\n\
2299 files that can be loaded by GDB are located.\n\
2300 In order to change the inferior's current working directory, the recommended\n\
2301 way is to use the \"set cwd\" command."), &cmdlist
);
2302 set_cmd_completer (c
, filename_completer
);
2304 add_com ("echo", class_support
, echo_command
, _("\
2305 Print a constant string. Give string as argument.\n\
2306 C escape sequences may be used in the argument.\n\
2307 No newline is added at the end of the argument;\n\
2308 use \"\\n\" if you want a newline to be printed.\n\
2309 Since leading and trailing whitespace are ignored in command arguments,\n\
2310 if you want to print some you must use \"\\\" before leading whitespace\n\
2311 to be printed or after trailing whitespace."));
2313 add_setshow_enum_cmd ("script-extension", class_support
,
2314 script_ext_enums
, &script_ext_mode
, _("\
2315 Set mode for script filename extension recognition."), _("\
2316 Show mode for script filename extension recognition."), _("\
2317 off == no filename extension recognition (all sourced files are GDB scripts)\n\
2318 soft == evaluate script according to filename extension, fallback to GDB script"
2320 strict == evaluate script according to filename extension, error if not supported"
2323 show_script_ext_mode
,
2324 &setlist
, &showlist
);
2326 add_com ("quit", class_support
, quit_command
, _("\
2328 Usage: quit [EXPR]\n\
2329 The optional expression EXPR, if present, is evaluated and the result\n\
2330 used as GDB's exit code. The default is zero."));
2331 c
= add_com ("help", class_support
, help_command
,
2332 _("Print list of commands."));
2333 set_cmd_completer (c
, command_completer
);
2334 add_com_alias ("q", "quit", class_support
, 1);
2335 add_com_alias ("h", "help", class_support
, 1);
2337 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
2338 Set verbosity."), _("\
2339 Show verbosity."), NULL
,
2342 &setlist
, &showlist
);
2344 add_basic_prefix_cmd ("history", class_support
, _("\
2345 Generic command for setting command history parameters."),
2346 &sethistlist
, "set history ", 0, &setlist
);
2347 add_show_prefix_cmd ("history", class_support
, _("\
2348 Generic command for showing command history parameters."),
2349 &showhistlist
, "show history ", 0, &showlist
);
2351 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
2352 Set history expansion on command input."), _("\
2353 Show history expansion on command input."), _("\
2354 Without an argument, history expansion is enabled."),
2356 show_history_expansion_p
,
2357 &sethistlist
, &showhistlist
);
2359 add_prefix_cmd ("info", class_info
, info_command
, _("\
2360 Generic command for showing things about the program being debugged."),
2361 &infolist
, "info ", 0, &cmdlist
);
2362 add_com_alias ("i", "info", class_info
, 1);
2363 add_com_alias ("inf", "info", class_info
, 1);
2365 add_com ("complete", class_obscure
, complete_command
,
2366 _("List the completions for the rest of the line as a command."));
2368 c
= add_show_prefix_cmd ("show", class_info
, _("\
2369 Generic command for showing things about the debugger."),
2370 &showlist
, "show ", 0, &cmdlist
);
2371 /* Another way to get at the same thing. */
2372 add_alias_cmd ("set", c
, class_info
, 0, &infolist
);
2374 c
= add_com ("with", class_vars
, with_command
, _("\
2375 Temporarily set SETTING to VALUE, run COMMAND, and restore SETTING.\n\
2376 Usage: with SETTING [VALUE] [-- COMMAND]\n\
2377 Usage: w SETTING [VALUE] [-- COMMAND]\n\
2378 With no COMMAND, repeats the last executed command.\n\
2380 SETTING is any setting you can change with the \"set\" subcommands.\n\
2382 with language pascal -- print obj\n\
2383 with print elements unlimited -- print obj\n\
2385 You can change multiple settings using nested with, and use\n\
2386 abbreviations for commands and/or values. E.g.:\n\
2387 w la p -- w p el u -- p obj"));
2388 set_cmd_completer_handle_brkchars (c
, with_command_completer
);
2389 add_com_alias ("w", "with", class_vars
, 1);
2391 add_internal_function ("_gdb_setting_str", _("\
2392 $_gdb_setting_str - returns the value of a GDB setting as a string.\n\
2393 Usage: $_gdb_setting_str (setting)\n\
2395 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2396 boolean values are \"off\", \"on\".\n\
2397 Some integer settings accept an unlimited value, returned\n\
2398 as \"unlimited\"."),
2399 gdb_setting_str_internal_fn
, NULL
);
2401 add_internal_function ("_gdb_setting", _("\
2402 $_gdb_setting - returns the value of a GDB setting.\n\
2403 Usage: $_gdb_setting (setting)\n\
2404 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2405 boolean values are \"off\", \"on\".\n\
2406 Some integer settings accept an unlimited value, returned\n\
2407 as 0 or -1 depending on the setting."),
2408 gdb_setting_internal_fn
, NULL
);
2410 add_internal_function ("_gdb_maint_setting_str", _("\
2411 $_gdb_maint_setting_str - returns the value of a GDB maintenance setting as a string.\n\
2412 Usage: $_gdb_maint_setting_str (setting)\n\
2414 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2415 boolean values are \"off\", \"on\".\n\
2416 Some integer settings accept an unlimited value, returned\n\
2417 as \"unlimited\"."),
2418 gdb_maint_setting_str_internal_fn
, NULL
);
2420 add_internal_function ("_gdb_maint_setting", _("\
2421 $_gdb_maint_setting - returns the value of a GDB maintenance setting.\n\
2422 Usage: $_gdb_maint_setting (setting)\n\
2423 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2424 boolean values are \"off\", \"on\".\n\
2425 Some integer settings accept an unlimited value, returned\n\
2426 as 0 or -1 depending on the setting."),
2427 gdb_maint_setting_internal_fn
, NULL
);
2429 add_cmd ("commands", no_set_class
, show_commands
, _("\
2430 Show the history of commands you typed.\n\
2431 You can supply a command number to start with, or a `+' to start after\n\
2432 the previous command number shown."),
2435 add_cmd ("version", no_set_class
, show_version
,
2436 _("Show what version of GDB this is."), &showlist
);
2438 add_cmd ("configuration", no_set_class
, show_configuration
,
2439 _("Show how GDB was configured at build time."), &showlist
);
2441 add_setshow_zinteger_cmd ("remote", no_class
, &remote_debug
, _("\
2442 Set debugging of remote protocol."), _("\
2443 Show debugging of remote protocol."), _("\
2444 When enabled, each packet sent or received with the remote target\n\
2448 &setdebuglist
, &showdebuglist
);
2450 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
2451 &remote_timeout
, _("\
2452 Set timeout limit to wait for target to respond."), _("\
2453 Show timeout limit to wait for target to respond."), _("\
2454 This value is used to set the time limit for gdb to wait for a response\n\
2457 show_remote_timeout
,
2458 &setlist
, &showlist
);
2460 add_basic_prefix_cmd ("debug", no_class
,
2461 _("Generic command for setting gdb debugging flags."),
2462 &setdebuglist
, "set debug ", 0, &setlist
);
2464 add_show_prefix_cmd ("debug", no_class
,
2465 _("Generic command for showing gdb debugging flags."),
2466 &showdebuglist
, "show debug ", 0, &showlist
);
2468 c
= add_com ("shell", class_support
, shell_command
, _("\
2469 Execute the rest of the line as a shell command.\n\
2470 With no arguments, run an inferior shell."));
2471 set_cmd_completer (c
, filename_completer
);
2473 add_com_alias ("!", "shell", class_support
, 0);
2475 c
= add_com ("edit", class_files
, edit_command
, _("\
2476 Edit specified file or function.\n\
2477 With no argument, edits file containing most recent line listed.\n\
2478 Editing targets can be specified in these ways:\n\
2479 FILE:LINENUM, to edit at that line in that file,\n\
2480 FUNCTION, to edit at the beginning of that function,\n\
2481 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2482 *ADDRESS, to edit at the line containing that address.\n\
2483 Uses EDITOR environment variable contents as editor (or ex as default)."));
2485 c
->completer
= location_completer
;
2487 c
= add_com ("pipe", class_support
, pipe_command
, _("\
2488 Send the output of a gdb command to a shell command.\n\
2489 Usage: | [COMMAND] | SHELL_COMMAND\n\
2490 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2491 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
2492 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2494 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
2496 The -d option indicates to use the string DELIM to separate COMMAND\n\
2497 from SHELL_COMMAND, in alternative to |. This is useful in\n\
2498 case COMMAND contains a | character.\n\
2500 With no COMMAND, repeat the last executed command\n\
2501 and send its output to SHELL_COMMAND."));
2502 set_cmd_completer_handle_brkchars (c
, pipe_command_completer
);
2503 add_com_alias ("|", "pipe", class_support
, 0);
2505 add_com ("list", class_files
, list_command
, _("\
2506 List specified function or line.\n\
2507 With no argument, lists ten more lines after or around previous listing.\n\
2508 \"list -\" lists the ten lines before a previous ten-line listing.\n\
2509 One argument specifies a line, and ten lines are listed around that line.\n\
2510 Two arguments with comma between specify starting and ending lines to list.\n\
2511 Lines can be specified in these ways:\n\
2512 LINENUM, to list around that line in current file,\n\
2513 FILE:LINENUM, to list around that line in that file,\n\
2514 FUNCTION, to list around beginning of that function,\n\
2515 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2516 *ADDRESS, to list around the line containing that address.\n\
2517 With two args, if one is empty, it stands for ten lines away from\n\
2520 By default, when a single location is given, display ten lines.\n\
2521 This can be changed using \"set listsize\", and the current value\n\
2522 can be shown using \"show listsize\"."));
2524 add_com_alias ("l", "list", class_files
, 1);
2527 add_com_alias ("file", "list", class_files
, 1);
2529 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
2530 Disassemble a specified section of memory.\n\
2531 Default is the function surrounding the pc of the selected frame.\n\
2533 With a /m modifier, source lines are included (if available).\n\
2534 This view is \"source centric\": the output is in source line order,\n\
2535 regardless of any optimization that is present. Only the main source file\n\
2536 is displayed, not those of, e.g., any inlined functions.\n\
2537 This modifier hasn't proved useful in practice and is deprecated\n\
2540 With a /s modifier, source lines are included (if available).\n\
2541 This differs from /m in two important respects:\n\
2542 - the output is still in pc address order, and\n\
2543 - file names and contents for all relevant source files are displayed.\n\
2545 With a /r modifier, raw instructions in hex are included.\n\
2547 With a single argument, the function surrounding that address is dumped.\n\
2548 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
2549 in the form of \"start,end\", or \"start,+length\".\n\
2551 Note that the address is interpreted as an expression, not as a location\n\
2552 like in the \"break\" command.\n\
2553 So, for example, if you want to disassemble function bar in file foo.c\n\
2554 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
2555 set_cmd_completer (c
, location_completer
);
2557 c
= add_com ("make", class_support
, make_command
, _("\
2558 Run the ``make'' program using the rest of the line as arguments."));
2559 set_cmd_completer (c
, filename_completer
);
2560 add_cmd ("user", no_class
, show_user
, _("\
2561 Show definitions of non-python/scheme user defined commands.\n\
2562 Argument is the name of the user defined command.\n\
2563 With no argument, show definitions of all user defined commands."), &showlist
);
2564 add_com ("apropos", class_support
, apropos_command
, _("\
2565 Search for commands matching a REGEXP.\n\
2566 Usage: apropos [-v] REGEXP\n\
2567 Flag -v indicates to produce a verbose output, showing full documentation\n\
2568 of the matching commands."));
2570 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
2571 &max_user_call_depth
, _("\
2572 Set the max call depth for non-python/scheme user-defined commands."), _("\
2573 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
2575 show_max_user_call_depth
,
2576 &setlist
, &showlist
);
2578 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
2579 Set tracing of GDB CLI commands."), _("\
2580 Show state of GDB CLI command tracing."), _("\
2581 When 'on', each command is displayed as it is executed."),
2584 &setlist
, &showlist
);
2586 const auto alias_opts
= make_alias_options_def_group (nullptr);
2588 static std::string alias_help
2589 = gdb::option::build_help (_("\
2590 Define a new command that is an alias of an existing command.\n\
2591 Usage: alias [-a] [--] ALIAS = COMMAND [DEFAULT-ARGS...]\n\
2592 ALIAS is the name of the alias command to create.\n\
2593 COMMAND is the command being aliased to.\n\
2598 GDB will automatically prepend the provided DEFAULT-ARGS to the list\n\
2599 of arguments explicitly provided when using ALIAS.\n\
2600 Use \"help aliases\" to list all user defined aliases and their default args.\n\
2603 Make \"spe\" an alias of \"set print elements\":\n\
2604 alias spe set print elements\n\
2605 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2606 alias -a set print elms set print elements\n\
2607 Make \"btf\" an alias of \"backtrace -full -past-entry -past-main\" :\n\
2608 alias btf = backtrace -full -past-entry -past-main\n\
2609 Make \"wLapPeu\" an alias of 2 nested \"with\":\n\
2610 alias wLapPeu = with language pascal -- with print elements unlimited --"),
2613 c
= add_com ("alias", class_support
, alias_command
,
2614 alias_help
.c_str ());
2616 set_cmd_completer_handle_brkchars (c
, alias_command_completer
);
2618 const char *source_help_text
= xstrprintf (_("\
2619 Read commands from a file named FILE.\n\
2621 Usage: source [-s] [-v] FILE\n\
2622 -s: search for the script in the source search path,\n\
2623 even if FILE contains directories.\n\
2624 -v: each command in FILE is echoed as it is executed.\n\
2626 Note that the file \"%s\" is read automatically in this way\n\
2627 when GDB is started."), GDBINIT
);
2628 c
= add_cmd ("source", class_support
, source_command
,
2629 source_help_text
, &cmdlist
);
2630 set_cmd_completer (c
, filename_completer
);