3 Copyright (C) 2000-2022 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 "gdbsupport/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"
57 #include "gdbsupport/gdb_tilde_expand.h"
60 #include "tui/tui.h" /* For tui_active et.al. */
67 /* Prototypes for local utility functions */
69 static void print_sal_location (const symtab_and_line
&sal
);
71 static void ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
72 const char *format
, ...)
73 ATTRIBUTE_PRINTF (2, 3);
75 static void filter_sals (std::vector
<symtab_and_line
> &);
79 unsigned int max_user_call_depth
;
81 /* Define all cmd_list_elements. */
83 /* Chain containing all defined commands. */
85 struct cmd_list_element
*cmdlist
;
87 /* Chain containing all defined info subcommands. */
89 struct cmd_list_element
*infolist
;
91 /* Chain containing all defined enable subcommands. */
93 struct cmd_list_element
*enablelist
;
95 /* Chain containing all defined disable subcommands. */
97 struct cmd_list_element
*disablelist
;
99 /* Chain containing all defined stop subcommands. */
101 struct cmd_list_element
*stoplist
;
103 /* Chain containing all defined delete subcommands. */
105 struct cmd_list_element
*deletelist
;
107 /* Chain containing all defined detach subcommands. */
109 struct cmd_list_element
*detachlist
;
111 /* Chain containing all defined kill subcommands. */
113 struct cmd_list_element
*killlist
;
115 /* Chain containing all defined set subcommands */
117 struct cmd_list_element
*setlist
;
119 /* Chain containing all defined unset subcommands */
121 struct cmd_list_element
*unsetlist
;
123 /* Chain containing all defined show subcommands. */
125 struct cmd_list_element
*showlist
;
127 /* Chain containing all defined \"set history\". */
129 struct cmd_list_element
*sethistlist
;
131 /* Chain containing all defined \"show history\". */
133 struct cmd_list_element
*showhistlist
;
135 /* Chain containing all defined \"unset history\". */
137 struct cmd_list_element
*unsethistlist
;
139 /* Chain containing all defined maintenance subcommands. */
141 struct cmd_list_element
*maintenancelist
;
143 /* Chain containing all defined "maintenance info" subcommands. */
145 struct cmd_list_element
*maintenanceinfolist
;
147 /* Chain containing all defined "maintenance print" subcommands. */
149 struct cmd_list_element
*maintenanceprintlist
;
151 /* Chain containing all defined "maintenance check" subcommands. */
153 struct cmd_list_element
*maintenancechecklist
;
155 /* Chain containing all defined "maintenance flush" subcommands. */
157 struct cmd_list_element
*maintenanceflushlist
;
159 struct cmd_list_element
*setprintlist
;
161 struct cmd_list_element
*showprintlist
;
163 struct cmd_list_element
*setdebuglist
;
165 struct cmd_list_element
*showdebuglist
;
167 struct cmd_list_element
*setchecklist
;
169 struct cmd_list_element
*showchecklist
;
171 struct cmd_list_element
*setsourcelist
;
173 struct cmd_list_element
*showsourcelist
;
175 /* Command tracing state. */
177 int source_verbose
= 0;
178 bool trace_commands
= false;
180 /* 'script-extension' option support. */
182 static const char script_ext_off
[] = "off";
183 static const char script_ext_soft
[] = "soft";
184 static const char script_ext_strict
[] = "strict";
186 static const char *const script_ext_enums
[] = {
193 static const char *script_ext_mode
= script_ext_soft
;
196 /* User-controllable flag to suppress event notification on CLI. */
198 static bool user_wants_cli_suppress_notification
= false;
200 /* Utility used everywhere when at least one argument is needed and
204 error_no_arg (const char *why
)
206 error (_("Argument required (%s)."), why
);
209 /* This implements the "info" prefix command. Normally such commands
210 are automatically handled by add_basic_prefix_cmd, but in this case
211 a separate command is used so that it can be hooked into by
215 info_command (const char *arg
, int from_tty
)
217 help_list (infolist
, "info ", all_commands
, gdb_stdout
);
220 /* See cli/cli-cmds.h. */
223 with_command_1 (const char *set_cmd_prefix
,
224 cmd_list_element
*setlist
, const char *args
, int from_tty
)
227 error (_("Missing arguments."));
229 const char *delim
= strstr (args
, "--");
230 const char *nested_cmd
= nullptr;
233 error (_("Missing setting before '--' delimiter"));
235 if (delim
== nullptr || *skip_spaces (&delim
[2]) == '\0')
236 nested_cmd
= repeat_previous ();
238 cmd_list_element
*set_cmd
= lookup_cmd (&args
, setlist
, set_cmd_prefix
,
240 /*allow_unknown=*/ 0,
241 /*ignore_help_classes=*/ 1);
242 gdb_assert (set_cmd
!= nullptr);
244 if (!set_cmd
->var
.has_value ())
245 error (_("Cannot use this setting with the \"with\" command"));
247 std::string temp_value
248 = (delim
== nullptr ? args
: std::string (args
, delim
- args
));
250 if (nested_cmd
== nullptr)
251 nested_cmd
= skip_spaces (delim
+ 2);
253 gdb_assert (set_cmd
->var
.has_value ());
254 std::string org_value
= get_setshow_command_value_string (*set_cmd
->var
);
256 /* Tweak the setting to the new temporary value. */
257 do_set_command (temp_value
.c_str (), from_tty
, set_cmd
);
261 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
263 /* Execute the nested command. */
264 execute_command (nested_cmd
, from_tty
);
266 catch (const gdb_exception
&ex
)
268 /* Restore the setting and rethrow. If restoring the setting
269 throws, swallow the new exception and warn. There's nothing
270 else we can reasonably do. */
273 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
275 catch (const gdb_exception
&ex2
)
277 warning (_("Couldn't restore setting: %s"), ex2
.what ());
283 /* Restore the setting. */
284 do_set_command (org_value
.c_str (), from_tty
, set_cmd
);
287 /* See cli/cli-cmds.h. */
290 with_command_completer_1 (const char *set_cmd_prefix
,
291 completion_tracker
&tracker
,
294 tracker
.set_use_custom_word_point (true);
296 const char *delim
= strstr (text
, "--");
298 /* If we're still not past the "--" delimiter, complete the "with"
299 command as if it was a "set" command. */
302 || !isspace (delim
[-1])
303 || !(isspace (delim
[2]) || delim
[2] == '\0'))
305 std::string new_text
= std::string (set_cmd_prefix
) + text
;
306 tracker
.advance_custom_word_point_by (-(int) strlen (set_cmd_prefix
));
307 complete_nested_command_line (tracker
, new_text
.c_str ());
311 /* We're past the "--" delimiter. Complete on the sub command. */
312 const char *nested_cmd
= skip_spaces (delim
+ 2);
313 tracker
.advance_custom_word_point_by (nested_cmd
- text
);
314 complete_nested_command_line (tracker
, nested_cmd
);
317 /* The "with" command. */
320 with_command (const char *args
, int from_tty
)
322 with_command_1 ("set ", setlist
, args
, from_tty
);
325 /* "with" command completer. */
328 with_command_completer (struct cmd_list_element
*ignore
,
329 completion_tracker
&tracker
,
330 const char *text
, const char * /*word*/)
332 with_command_completer_1 ("set ", tracker
, text
);
335 /* Look up the contents of TEXT as a command usable with default args.
336 Throws an error if no such command is found.
337 Return the found command and advances TEXT past the found command.
338 If the found command is a postfix command, set *PREFIX_CMD to its
341 static struct cmd_list_element
*
342 lookup_cmd_for_default_args (const char **text
,
343 struct cmd_list_element
**prefix_cmd
)
345 const char *orig_text
= *text
;
346 struct cmd_list_element
*lcmd
;
348 if (*text
== nullptr || skip_spaces (*text
) == nullptr)
349 error (_("ALIAS missing."));
351 /* We first use lookup_cmd to verify TEXT unambiguously identifies
353 lcmd
= lookup_cmd (text
, cmdlist
, "", NULL
,
354 /*allow_unknown=*/ 0,
355 /*ignore_help_classes=*/ 1);
357 /* Note that we accept default args for prefix commands,
358 as a prefix command can also be a valid usable
359 command accepting some arguments.
360 For example, "thread apply" applies a command to a
361 list of thread ids, and is also the prefix command for
364 /* We have an unambiguous command for which default args
365 can be specified. What remains after having found LCMD
366 is either spaces, or the default args character. */
368 /* We then use lookup_cmd_composition to detect if the user
369 has specified an alias, and find the possible prefix_cmd
371 struct cmd_list_element
*alias
, *cmd
;
372 lookup_cmd_composition
373 (std::string (orig_text
, *text
- orig_text
).c_str (),
374 &alias
, prefix_cmd
, &cmd
);
375 gdb_assert (cmd
!= nullptr);
376 gdb_assert (cmd
== lcmd
);
377 if (alias
!= nullptr)
383 /* Provide documentation on command or list given by COMMAND. FROM_TTY
387 help_command (const char *command
, int from_tty
)
389 help_cmd (command
, gdb_stdout
);
393 /* Note: The "complete" command is used by Emacs to implement completion.
394 [Is that why this function writes output with *_unfiltered?] */
397 complete_command (const char *arg
, int from_tty
)
401 if (max_completions
== 0)
403 /* Only print this for non-mi frontends. An MI frontend may not
404 be able to handle this. */
405 if (!current_uiout
->is_mi_like_p ())
407 printf_unfiltered (_("max-completions is zero,"
408 " completion is disabled.\n"));
416 int quote_char
= '\0';
419 completion_result result
= complete (arg
, &word
, "e_char
);
421 if (result
.number_matches
!= 0)
423 std::string
arg_prefix (arg
, word
- arg
);
425 if (result
.number_matches
== 1)
426 printf_unfiltered ("%s%s\n", arg_prefix
.c_str (), result
.match_list
[0]);
429 result
.sort_match_list ();
431 for (size_t i
= 0; i
< result
.number_matches
; i
++)
433 printf_unfiltered ("%s%s",
435 result
.match_list
[i
+ 1]);
437 printf_unfiltered ("%c", quote_char
);
438 printf_unfiltered ("\n");
442 if (result
.number_matches
== max_completions
)
444 /* ARG_PREFIX and WORD are included in the output so that emacs
445 will include the message in the output. */
446 printf_unfiltered (_("%s%s %s\n"),
447 arg_prefix
.c_str (), word
,
448 get_max_completions_reached_message ());
454 is_complete_command (struct cmd_list_element
*c
)
456 return cmd_simple_func_eq (c
, complete_command
);
460 show_version (const char *args
, int from_tty
)
462 print_gdb_version (gdb_stdout
, true);
467 show_configuration (const char *args
, int from_tty
)
469 print_gdb_configuration (gdb_stdout
);
472 /* Handle the quit command. */
475 quit_command (const char *args
, int from_tty
)
479 /* An optional expression may be used to cause gdb to terminate with
480 the value of that expression. */
483 struct value
*val
= parse_and_eval (args
);
485 exit_code
= (int) value_as_long (val
);
488 if (!quit_confirm ())
489 error (_("Not confirmed."));
491 query_if_trace_running (from_tty
);
493 quit_force (args
? &exit_code
: NULL
, from_tty
);
497 pwd_command (const char *args
, int from_tty
)
500 error (_("The \"pwd\" command does not take an argument: %s"), args
);
502 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
505 error (_("Error finding name of working directory: %s"),
506 safe_strerror (errno
));
508 if (strcmp (cwd
.get (), current_directory
) != 0)
509 gdb_printf (_("Working directory %ps\n (canonically %ps).\n"),
510 styled_string (file_name_style
.style (),
512 styled_string (file_name_style
.style (), cwd
.get ()));
514 gdb_printf (_("Working directory %ps.\n"),
515 styled_string (file_name_style
.style (),
520 cd_command (const char *dir
, int from_tty
)
523 /* Found something other than leading repetitions of "/..". */
527 /* If the new directory is absolute, repeat is a no-op; if relative,
528 repeat might be useful but is more likely to be a mistake. */
531 gdb::unique_xmalloc_ptr
<char> dir_holder
532 (tilde_expand (dir
!= NULL
? dir
: "~"));
533 dir
= dir_holder
.get ();
536 perror_with_name (dir
);
538 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
539 /* There's too much mess with DOSish names like "d:", "d:.",
540 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
541 simply get the canonicalized name of the current directory. */
542 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
547 if (IS_DIR_SEPARATOR (dir
[len
- 1]))
549 /* Remove the trailing slash unless this is a root directory
550 (including a drive letter on non-Unix systems). */
551 if (!(len
== 1) /* "/" */
552 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
553 && !(len
== 3 && dir
[1] == ':') /* "d:/" */
559 dir_holder
.reset (savestring (dir
, len
));
560 if (IS_ABSOLUTE_PATH (dir_holder
.get ()))
562 xfree (current_directory
);
563 current_directory
= dir_holder
.release ();
567 if (IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1]))
568 current_directory
= concat (current_directory
, dir_holder
.get (),
571 current_directory
= concat (current_directory
, SLASH_STRING
,
572 dir_holder
.get (), (char *) NULL
);
575 /* Now simplify any occurrences of `.' and `..' in the pathname. */
578 for (p
= current_directory
; *p
;)
580 if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.'
581 && (p
[2] == 0 || IS_DIR_SEPARATOR (p
[2])))
582 memmove (p
, p
+ 2, strlen (p
+ 2) + 1);
583 else if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.' && p
[2] == '.'
584 && (p
[3] == 0 || IS_DIR_SEPARATOR (p
[3])))
588 /* Search backwards for the directory just before the "/.."
589 and obliterate it and the "/..". */
592 while (q
!= current_directory
&& !IS_DIR_SEPARATOR (q
[-1]))
595 if (q
== current_directory
)
596 /* current_directory is
597 a relative pathname ("can't happen"--leave it alone). */
601 memmove (q
- 1, p
+ 3, strlen (p
+ 3) + 1);
606 /* We are dealing with leading repetitions of "/..", for
607 example "/../..", which is the Mach super-root. */
617 forget_cached_source_info ();
620 pwd_command ((char *) 0, 1);
623 /* Show the current value of the 'script-extension' option. */
626 show_script_ext_mode (struct ui_file
*file
, int from_tty
,
627 struct cmd_list_element
*c
, const char *value
)
630 _("Script filename extension recognition is \"%s\".\n"),
634 /* Try to open SCRIPT_FILE.
635 If successful, the full path name is stored in *FULL_PATHP,
636 and the stream is returned.
637 If not successful, return NULL; errno is set for the last file
640 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
641 search for it in the source search path. */
643 gdb::optional
<open_script
>
644 find_and_open_script (const char *script_file
, int search_path
)
647 openp_flags search_flags
= OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
;
648 gdb::optional
<open_script
> opened
;
650 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (script_file
));
653 search_flags
|= OPF_SEARCH_IN_PATH
;
655 /* Search for and open 'file' on the search path used for source
656 files. Put the full location in *FULL_PATHP. */
657 gdb::unique_xmalloc_ptr
<char> full_path
;
658 fd
= openp (source_path
.c_str (), search_flags
,
659 file
.get (), O_RDONLY
, &full_path
);
664 FILE *result
= fdopen (fd
, FOPEN_RT
);
667 int save_errno
= errno
;
673 opened
.emplace (gdb_file_up (result
), std::move (full_path
));
678 /* Load script FILE, which has already been opened as STREAM.
679 FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
680 This is provided as FILE may have been found via the source search path.
681 An important thing to note here is that FILE may be a symlink to a file
682 with a different or non-existing suffix, and thus one cannot infer the
683 extension language from FILE_TO_OPEN. */
686 source_script_from_stream (FILE *stream
, const char *file
,
687 const char *file_to_open
)
689 if (script_ext_mode
!= script_ext_off
)
691 const struct extension_language_defn
*extlang
692 = get_ext_lang_of_file (file
);
696 if (ext_lang_present_p (extlang
))
698 script_sourcer_func
*sourcer
699 = ext_lang_script_sourcer (extlang
);
701 gdb_assert (sourcer
!= NULL
);
702 sourcer (extlang
, stream
, file_to_open
);
705 else if (script_ext_mode
== script_ext_soft
)
707 /* Assume the file is a gdb script.
708 This is handled below. */
711 throw_ext_lang_unsupported (extlang
);
715 script_from_file (stream
, file
);
718 /* Worker to perform the "source" command.
720 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
721 search for it in the source search path. */
724 source_script_with_search (const char *file
, int from_tty
, int search_path
)
727 if (file
== NULL
|| *file
== 0)
728 error (_("source command requires file name of file to source."));
730 gdb::optional
<open_script
> opened
= find_and_open_script (file
, search_path
);
733 /* The script wasn't found, or was otherwise inaccessible.
734 If the source command was invoked interactively, throw an
735 error. Otherwise (e.g. if it was invoked by a script),
736 just emit a warning, rather than cause an error. */
738 perror_with_name (file
);
741 perror_warning_with_name (file
);
746 /* The python support reopens the file, so we need to pass full_path here
747 in case the file was found on the search path. It's useful to do this
748 anyway so that error messages show the actual file used. But only do
749 this if we (may have) used search_path, as printing the full path in
750 errors for the non-search case can be more noise than signal. */
751 const char *file_to_open
;
752 std::string tilde_expanded_file
;
754 file_to_open
= opened
->full_path
.get ();
757 tilde_expanded_file
= gdb_tilde_expand (file
);
758 file_to_open
= tilde_expanded_file
.c_str ();
760 source_script_from_stream (opened
->stream
.get (), file
, file_to_open
);
763 /* Wrapper around source_script_with_search to export it to main.c
764 for use in loading .gdbinit scripts. */
767 source_script (const char *file
, int from_tty
)
769 source_script_with_search (file
, from_tty
, 0);
773 source_command (const char *args
, int from_tty
)
775 const char *file
= args
;
778 scoped_restore save_source_verbose
= make_scoped_restore (&source_verbose
);
780 /* -v causes the source command to run in verbose mode.
781 -s causes the file to be searched in the source search path,
782 even if the file name contains a '/'.
783 We still have to be able to handle filenames with spaces in a
784 backward compatible way, so buildargv is not appropriate. */
788 while (args
[0] != '\0')
790 /* Make sure leading white space does not break the
792 args
= skip_spaces (args
);
797 if (args
[1] == 'v' && isspace (args
[2]))
801 /* Skip passed -v. */
804 else if (args
[1] == 's' && isspace (args
[2]))
808 /* Skip passed -s. */
815 file
= skip_spaces (args
);
818 source_script_with_search (file
, from_tty
, search_path
);
823 echo_command (const char *text
, int from_tty
)
825 const char *p
= text
;
829 while ((c
= *p
++) != '\0')
833 /* \ at end of argument is used after spaces
834 so they won't be lost. */
838 c
= parse_escape (get_current_arch (), &p
);
840 gdb_printf ("%c", c
);
843 gdb_printf ("%c", c
);
846 gdb_stdout
->reset_style ();
848 /* Force this output to appear now. */
849 gdb_flush (gdb_stdout
);
852 /* Sets the last launched shell command convenience variables based on
856 exit_status_set_internal_vars (int exit_status
)
858 struct internalvar
*var_code
= lookup_internalvar ("_shell_exitcode");
859 struct internalvar
*var_signal
= lookup_internalvar ("_shell_exitsignal");
861 clear_internalvar (var_code
);
862 clear_internalvar (var_signal
);
863 if (WIFEXITED (exit_status
))
864 set_internalvar_integer (var_code
, WEXITSTATUS (exit_status
));
866 else if (WIFSIGNALED (exit_status
) && WTERMSIG (exit_status
) == -1)
868 /* The -1 condition can happen on MinGW, if we don't recognize
869 the fatal exception code encoded in the exit status; see
870 gdbsupport/gdb_wait.c. We don't want to lose information in
871 the exit status in that case. Record it as a normal exit
872 with the full exit status, including the higher 0xC0000000
874 set_internalvar_integer (var_code
, exit_status
);
877 else if (WIFSIGNALED (exit_status
))
878 set_internalvar_integer (var_signal
, WTERMSIG (exit_status
));
880 warning (_("unexpected shell command exit status %d"), exit_status
);
884 shell_escape (const char *arg
, int from_tty
)
886 #if defined(CANT_FORK) || \
887 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
888 /* If ARG is NULL, they want an inferior shell, but `system' just
889 reports if the shell is available when passed a NULL arg. */
890 int rc
= system (arg
? arg
: "");
893 arg
= "inferior shell";
896 gdb_printf (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
897 safe_strerror (errno
));
899 gdb_printf (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
901 /* Make sure to return to the directory GDB thinks it is, in case
902 the shell command we just ran changed it. */
903 chdir (current_directory
);
905 exit_status_set_internal_vars (rc
);
906 #else /* Can fork. */
909 if ((pid
= vfork ()) == 0)
911 const char *p
, *user_shell
= get_shell ();
915 /* Get the name of the shell for arg0. */
916 p
= lbasename (user_shell
);
919 execl (user_shell
, p
, (char *) 0);
921 execl (user_shell
, p
, "-c", arg
, (char *) 0);
923 gdb_printf (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
924 safe_strerror (errno
));
929 waitpid (pid
, &status
, 0);
931 error (_("Fork failed"));
932 exit_status_set_internal_vars (status
);
933 #endif /* Can fork. */
936 /* Implementation of the "shell" command. */
939 shell_command (const char *arg
, int from_tty
)
941 shell_escape (arg
, from_tty
);
945 edit_command (const char *arg
, int from_tty
)
947 struct symtab_and_line sal
;
952 /* Pull in the current default source line if necessary. */
955 set_default_source_symtab_and_line ();
956 sal
= get_current_source_symtab_and_line ();
959 /* Bare "edit" edits file with present line. */
964 error (_("No default source file yet."));
965 sal
.line
+= get_lines_to_list () / 2;
971 /* Now should only be one argument -- decode it in SAL. */
973 event_location_up location
= string_to_event_location (&arg1
,
977 error (_("Junk at end of line specification."));
979 std::vector
<symtab_and_line
> sals
= decode_line_1 (location
.get (),
980 DECODE_LINE_LIST_MODE
,
989 if (sals
.size () > 1)
991 ambiguous_line_spec (sals
,
992 _("Specified line is ambiguous:\n"));
998 /* If line was specified by address, first print exactly which
999 line, and which file. In this case, sal.symtab == 0 means
1000 address is outside of all known source files, not that user
1001 failed to give a filename. */
1004 struct gdbarch
*gdbarch
;
1006 if (sal
.symtab
== 0)
1007 error (_("No source file for address %s."),
1008 paddress (get_current_arch (), sal
.pc
));
1010 gdbarch
= sal
.symtab
->compunit ()->objfile ()->arch ();
1011 sym
= find_pc_function (sal
.pc
);
1013 gdb_printf ("%s is in %s (%s:%d).\n",
1014 paddress (gdbarch
, sal
.pc
),
1016 symtab_to_filename_for_display (sal
.symtab
),
1019 gdb_printf ("%s is at %s:%d.\n",
1020 paddress (gdbarch
, sal
.pc
),
1021 symtab_to_filename_for_display (sal
.symtab
),
1025 /* If what was given does not imply a symtab, it must be an
1026 undebuggable symbol which means no source code. */
1028 if (sal
.symtab
== 0)
1029 error (_("No line number known for %s."), arg
);
1032 if ((editor
= getenv ("EDITOR")) == NULL
)
1035 fn
= symtab_to_fullname (sal
.symtab
);
1037 /* Quote the file name, in case it has whitespace or other special
1039 gdb::unique_xmalloc_ptr
<char> p
1040 = xstrprintf ("%s +%d \"%s\"", editor
, sal
.line
, fn
);
1041 shell_escape (p
.get (), from_tty
);
1044 /* The options for the "pipe" command. */
1046 struct pipe_cmd_opts
1049 std::string delimiter
;
1052 static const gdb::option::option_def pipe_cmd_option_defs
[] = {
1054 gdb::option::string_option_def
<pipe_cmd_opts
> {
1056 [] (pipe_cmd_opts
*opts
) { return &opts
->delimiter
; },
1058 N_("Indicates to use the specified delimiter string to separate\n\
1059 COMMAND from SHELL_COMMAND, in alternative to |. This is useful in\n\
1060 case COMMAND contains a | character."),
1065 /* Create an option_def_group for the "pipe" command's options, with
1068 static inline gdb::option::option_def_group
1069 make_pipe_cmd_options_def_group (pipe_cmd_opts
*opts
)
1071 return {{pipe_cmd_option_defs
}, opts
};
1074 /* Implementation of the "pipe" command. */
1077 pipe_command (const char *arg
, int from_tty
)
1081 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1082 gdb::option::process_options
1083 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
1085 const char *delim
= "|";
1086 if (!opts
.delimiter
.empty ())
1087 delim
= opts
.delimiter
.c_str ();
1089 const char *command
= arg
;
1090 if (command
== nullptr)
1091 error (_("Missing COMMAND"));
1093 arg
= strstr (arg
, delim
);
1096 error (_("Missing delimiter before SHELL_COMMAND"));
1098 std::string
gdb_cmd (command
, arg
- command
);
1100 arg
+= strlen (delim
); /* Skip the delimiter. */
1102 if (gdb_cmd
.empty ())
1103 gdb_cmd
= repeat_previous ();
1105 const char *shell_command
= skip_spaces (arg
);
1106 if (*shell_command
== '\0')
1107 error (_("Missing SHELL_COMMAND"));
1109 FILE *to_shell_command
= popen (shell_command
, "w");
1111 if (to_shell_command
== nullptr)
1112 error (_("Error launching \"%s\""), shell_command
);
1116 stdio_file
pipe_file (to_shell_command
);
1118 execute_command_to_ui_file (&pipe_file
, gdb_cmd
.c_str (), from_tty
);
1122 pclose (to_shell_command
);
1126 int exit_status
= pclose (to_shell_command
);
1128 if (exit_status
< 0)
1129 error (_("shell command \"%s\" failed: %s"), shell_command
,
1130 safe_strerror (errno
));
1131 exit_status_set_internal_vars (exit_status
);
1134 /* Completer for the pipe command. */
1137 pipe_command_completer (struct cmd_list_element
*ignore
,
1138 completion_tracker
&tracker
,
1139 const char *text
, const char *word_ignored
)
1143 const char *org_text
= text
;
1144 auto grp
= make_pipe_cmd_options_def_group (&opts
);
1145 if (gdb::option::complete_options
1146 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
))
1149 const char *delimiter
= "|";
1150 if (!opts
.delimiter
.empty ())
1151 delimiter
= opts
.delimiter
.c_str ();
1153 /* Check if we're past option values already. */
1154 if (text
> org_text
&& !isspace (text
[-1]))
1157 const char *delim
= strstr (text
, delimiter
);
1159 /* If we're still not past the delimiter, complete the gdb
1161 if (delim
== nullptr || delim
== text
)
1163 complete_nested_command_line (tracker
, text
);
1167 /* We're past the delimiter. What follows is a shell command, which
1168 we don't know how to complete. */
1172 list_command (const char *arg
, int from_tty
)
1179 int linenum_beg
= 0;
1182 /* Pull in the current default source line if necessary. */
1183 if (arg
== NULL
|| ((arg
[0] == '+' || arg
[0] == '-') && arg
[1] == '\0'))
1185 set_default_source_symtab_and_line ();
1186 symtab_and_line cursal
= get_current_source_symtab_and_line ();
1188 /* If this is the first "list" since we've set the current
1189 source line, center the listing around that line. */
1190 if (get_first_line_listed () == 0)
1194 first
= std::max (cursal
.line
- get_lines_to_list () / 2, 1);
1196 /* A small special case --- if listing backwards, and we
1197 should list only one line, list the preceding line,
1198 instead of the exact line we've just shown after e.g.,
1199 stopping for a breakpoint. */
1200 if (arg
!= NULL
&& arg
[0] == '-'
1201 && get_lines_to_list () == 1 && first
> 1)
1204 print_source_lines (cursal
.symtab
, source_lines_range (first
), 0);
1207 /* "l" or "l +" lists next ten lines. */
1208 else if (arg
== NULL
|| arg
[0] == '+')
1209 print_source_lines (cursal
.symtab
,
1210 source_lines_range (cursal
.line
), 0);
1212 /* "l -" lists previous ten lines, the ones before the ten just
1214 else if (arg
[0] == '-')
1216 if (get_first_line_listed () == 1)
1217 error (_("Already at the start of %s."),
1218 symtab_to_filename_for_display (cursal
.symtab
));
1219 source_lines_range
range (get_first_line_listed (),
1220 source_lines_range::BACKWARD
);
1221 print_source_lines (cursal
.symtab
, range
, 0);
1227 /* Now if there is only one argument, decode it in SAL
1229 If there are two arguments, decode them in SAL and SAL_END
1230 and clear NO_END; however, if one of the arguments is blank,
1231 set DUMMY_BEG or DUMMY_END to record that fact. */
1233 if (!have_full_symbols () && !have_partial_symbols ())
1234 error (_("No symbol table is loaded. Use the \"file\" command."));
1236 std::vector
<symtab_and_line
> sals
;
1237 symtab_and_line sal
, sal_end
;
1244 event_location_up location
= string_to_event_location (&arg1
,
1247 /* We know that the ARG string is not empty, yet the attempt to parse
1248 a location from the string consumed no characters. This most
1249 likely means that the first thing in ARG looks like a location
1250 condition, and so the string_to_event_location call stopped
1253 error (_("Junk at end of line specification."));
1255 sals
= decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1267 /* Record whether the BEG arg is all digits. */
1269 for (p
= arg
; p
!= arg1
&& *p
>= '0' && *p
<= '9'; p
++);
1270 linenum_beg
= (p
== arg1
);
1272 /* Save the range of the first argument, in case we need to let the
1273 user know it was ambiguous. */
1274 const char *beg
= arg
;
1275 size_t beg_len
= arg1
- beg
;
1277 while (*arg1
== ' ' || *arg1
== '\t')
1282 if (sals
.size () > 1)
1284 ambiguous_line_spec (sals
,
1285 _("Specified first line '%.*s' is ambiguous:\n"),
1286 (int) beg_len
, beg
);
1290 while (*arg1
== ' ' || *arg1
== '\t')
1296 /* Save the last argument, in case we need to let the user
1297 know it was ambiguous. */
1298 const char *end_arg
= arg1
;
1300 event_location_up location
1301 = string_to_event_location (&arg1
, current_language
);
1304 error (_("Junk at end of line specification."));
1306 std::vector
<symtab_and_line
> sals_end
1308 ? decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1310 : decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1311 NULL
, sal
.symtab
, sal
.line
));
1313 filter_sals (sals_end
);
1314 if (sals_end
.empty ())
1316 if (sals_end
.size () > 1)
1318 ambiguous_line_spec (sals_end
,
1319 _("Specified last line '%s' is ambiguous:\n"),
1323 sal_end
= sals_end
[0];
1328 error (_("Junk at end of line specification."));
1330 if (!no_end
&& !dummy_beg
&& !dummy_end
1331 && sal
.symtab
!= sal_end
.symtab
)
1332 error (_("Specified first and last lines are in different files."));
1333 if (dummy_beg
&& dummy_end
)
1334 error (_("Two empty args do not say what lines to list."));
1336 /* If line was specified by address,
1337 first print exactly which line, and which file.
1339 In this case, sal.symtab == 0 means address is outside of all
1340 known source files, not that user failed to give a filename. */
1343 struct gdbarch
*gdbarch
;
1345 if (sal
.symtab
== 0)
1346 error (_("No source file for address %s."),
1347 paddress (get_current_arch (), sal
.pc
));
1349 gdbarch
= sal
.symtab
->compunit ()->objfile ()->arch ();
1350 sym
= find_pc_function (sal
.pc
);
1352 gdb_printf ("%s is in %s (%s:%d).\n",
1353 paddress (gdbarch
, sal
.pc
),
1355 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1357 gdb_printf ("%s is at %s:%d.\n",
1358 paddress (gdbarch
, sal
.pc
),
1359 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1362 /* If line was not specified by just a line number, and it does not
1363 imply a symtab, it must be an undebuggable symbol which means no
1366 if (!linenum_beg
&& sal
.symtab
== 0)
1367 error (_("No line number known for %s."), arg
);
1369 /* If this command is repeated with RET,
1370 turn it into the no-arg variant. */
1373 set_repeat_arguments ("");
1375 if (dummy_beg
&& sal_end
.symtab
== 0)
1376 error (_("No default source file yet. Do \"help list\"."));
1379 source_lines_range
range (sal_end
.line
+ 1,
1380 source_lines_range::BACKWARD
);
1381 print_source_lines (sal_end
.symtab
, range
, 0);
1383 else if (sal
.symtab
== 0)
1384 error (_("No default source file yet. Do \"help list\"."));
1387 for (int i
= 0; i
< sals
.size (); i
++)
1390 int first_line
= sal
.line
- get_lines_to_list () / 2;
1393 if (sals
.size () > 1)
1394 print_sal_location (sal
);
1395 print_source_lines (sal
.symtab
, source_lines_range (first_line
), 0);
1399 print_source_lines (sal
.symtab
, source_lines_range (sal
.line
), 0);
1401 print_source_lines (sal
.symtab
,
1402 source_lines_range (sal
.line
, (sal_end
.line
+ 1)),
1406 /* Subroutine of disassemble_command to simplify it.
1407 Perform the disassembly.
1408 NAME is the name of the function if known, or NULL.
1409 [LOW,HIGH) are the range of addresses to disassemble.
1410 BLOCK is the block to disassemble; it needs to be provided
1411 when non-contiguous blocks are disassembled; otherwise
1413 MIXED is non-zero to print source with the assembler. */
1416 print_disassembly (struct gdbarch
*gdbarch
, const char *name
,
1417 CORE_ADDR low
, CORE_ADDR high
,
1418 const struct block
*block
,
1419 gdb_disassembly_flags flags
)
1422 if (tui_is_window_visible (DISASSEM_WIN
))
1423 tui_show_assembly (gdbarch
, low
);
1427 gdb_printf (_("Dump of assembler code "));
1429 gdb_printf (_("for function %ps:\n"),
1430 styled_string (function_name_style
.style (), name
));
1431 if (block
== nullptr || block
->is_contiguous ())
1434 gdb_printf (_("from %ps to %ps:\n"),
1435 styled_string (address_style
.style (),
1436 paddress (gdbarch
, low
)),
1437 styled_string (address_style
.style (),
1438 paddress (gdbarch
, high
)));
1440 /* Dump the specified range. */
1441 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1, low
, high
);
1445 for (const blockrange
&range
: block
->ranges ())
1447 CORE_ADDR range_low
= range
.start ();
1448 CORE_ADDR range_high
= range
.end ();
1450 gdb_printf (_("Address range %ps to %ps:\n"),
1451 styled_string (address_style
.style (),
1452 paddress (gdbarch
, range_low
)),
1453 styled_string (address_style
.style (),
1454 paddress (gdbarch
, range_high
)));
1455 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1,
1456 range_low
, range_high
);
1459 gdb_printf (_("End of assembler dump.\n"));
1463 /* Subroutine of disassemble_command to simplify it.
1464 Print a disassembly of the current function according to FLAGS. */
1467 disassemble_current_function (gdb_disassembly_flags flags
)
1469 struct frame_info
*frame
;
1470 struct gdbarch
*gdbarch
;
1471 CORE_ADDR low
, high
, pc
;
1473 const struct block
*block
;
1475 frame
= get_selected_frame (_("No frame selected."));
1476 gdbarch
= get_frame_arch (frame
);
1477 pc
= get_frame_address_in_block (frame
);
1478 if (find_pc_partial_function (pc
, &name
, &low
, &high
, &block
) == 0)
1479 error (_("No function contains program counter for selected frame."));
1481 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1484 /* FIXME: cagney/2004-02-07: This should be an observer. */
1485 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1487 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1489 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1492 /* Dump a specified section of assembly code.
1496 - dump the assembly code for the function of the current pc
1497 disassemble [/mrs] addr
1498 - dump the assembly code for the function at ADDR
1499 disassemble [/mrs] low,high
1500 disassemble [/mrs] low,+length
1501 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1503 A /m modifier will include source code with the assembly in a
1504 "source centric" view. This view lists only the file of the first insn,
1505 even if other source files are involved (e.g., inlined functions), and
1506 the output is in source order, even with optimized code. This view is
1507 considered deprecated as it hasn't been useful in practice.
1509 A /r modifier will include raw instructions in hex with the assembly.
1511 A /s modifier will include source code with the assembly, like /m, with
1512 two important differences:
1513 1) The output is still in pc address order.
1514 2) File names and contents for all relevant source files are displayed. */
1517 disassemble_command (const char *arg
, int from_tty
)
1519 struct gdbarch
*gdbarch
= get_current_arch ();
1520 CORE_ADDR low
, high
;
1521 const general_symbol_info
*symbol
= nullptr;
1524 gdb_disassembly_flags flags
;
1526 const struct block
*block
= nullptr;
1537 error (_("Missing modifier."));
1539 while (*p
&& ! isspace (*p
))
1544 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1547 flags
|= DISASSEMBLY_RAW_INSN
;
1550 flags
|= DISASSEMBLY_SOURCE
;
1553 error (_("Invalid disassembly modifier."));
1557 p
= skip_spaces (p
);
1560 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1561 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1562 error (_("Cannot specify both /m and /s."));
1566 flags
|= DISASSEMBLY_OMIT_FNAME
;
1567 disassemble_current_function (flags
);
1571 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1577 if (!find_pc_partial_function_sym (pc
, &symbol
, &low
, &high
, &block
))
1578 error (_("No function contains specified address."));
1581 name
= symbol
->print_name ();
1583 name
= symbol
->linkage_name ();
1586 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1589 /* FIXME: cagney/2004-02-07: This should be an observer. */
1590 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1592 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1593 flags
|= DISASSEMBLY_OMIT_FNAME
;
1597 /* Two arguments. */
1600 p
= skip_spaces (p
);
1606 high
= parse_and_eval_address (p
);
1611 print_disassembly (gdbarch
, name
, low
, high
, block
, flags
);
1615 make_command (const char *arg
, int from_tty
)
1618 shell_escape ("make", from_tty
);
1621 std::string cmd
= std::string ("make ") + arg
;
1623 shell_escape (cmd
.c_str (), from_tty
);
1628 show_user (const char *args
, int from_tty
)
1630 struct cmd_list_element
*c
;
1634 const char *comname
= args
;
1636 c
= lookup_cmd (&comname
, cmdlist
, "", NULL
, 0, 1);
1637 if (!cli_user_command_p (c
))
1638 error (_("Not a user command."));
1639 show_user_1 (c
, "", args
, gdb_stdout
);
1643 for (c
= cmdlist
; c
; c
= c
->next
)
1645 if (cli_user_command_p (c
) || c
->is_prefix ())
1646 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1651 /* Return true if COMMAND or any of its sub-commands is a user defined command.
1652 This is a helper function for show_user_completer. */
1655 has_user_subcmd (struct cmd_list_element
*command
)
1657 if (cli_user_command_p (command
))
1660 /* Alias command can yield false positive. Ignore them as the targeted
1661 command should be reachable anyway. */
1662 if (command
->is_alias ())
1665 if (command
->is_prefix ())
1666 for (struct cmd_list_element
*subcommand
= *command
->subcommands
;
1667 subcommand
!= nullptr;
1668 subcommand
= subcommand
->next
)
1669 if (has_user_subcmd (subcommand
))
1675 /* Implement completer for the 'show user' command. */
1678 show_user_completer (cmd_list_element
*,
1679 completion_tracker
&tracker
, const char *text
,
1682 struct cmd_list_element
*cmd_group
= cmdlist
;
1684 /* TEXT can contain a chain of commands and subcommands. Follow the
1685 commands chain until we reach the point where the user wants a
1689 const char *curr_cmd
= text
;
1690 const char *after
= skip_to_space (text
);
1691 const size_t curr_cmd_len
= after
- text
;
1692 text
= skip_spaces (after
);
1694 for (struct cmd_list_element
*c
= cmd_group
; c
!= nullptr; c
= c
->next
)
1696 if (strlen (c
->name
) == curr_cmd_len
1697 && strncmp (c
->name
, curr_cmd
, curr_cmd_len
) == 0)
1699 if (c
->subcommands
== nullptr)
1700 /* We arrived after a command with no child, so nothing more
1704 cmd_group
= *c
->subcommands
;
1710 const int wordlen
= strlen (word
);
1711 for (struct cmd_list_element
*c
= cmd_group
; c
!= nullptr; c
= c
->next
)
1712 if (has_user_subcmd (c
))
1714 if (strncmp (c
->name
, word
, wordlen
) == 0)
1715 tracker
.add_completion
1716 (gdb::unique_xmalloc_ptr
<char> (xstrdup (c
->name
)));
1720 /* Search through names of commands and documentations for a certain
1721 regular expression. */
1724 apropos_command (const char *arg
, int from_tty
)
1726 bool verbose
= arg
&& check_for_argument (&arg
, "-v", 2);
1728 if (arg
== NULL
|| *arg
== '\0')
1729 error (_("REGEXP string is empty"));
1731 compiled_regex
pattern (arg
, REG_ICASE
,
1732 _("Error in regular expression"));
1734 apropos_cmd (gdb_stdout
, cmdlist
, verbose
, pattern
, "");
1737 /* The options for the "alias" command. */
1742 bool abbrev_flag
= false;
1745 static const gdb::option::option_def alias_option_defs
[] = {
1747 gdb::option::flag_option_def
<alias_opts
> {
1749 [] (alias_opts
*opts
) { return &opts
->abbrev_flag
; },
1750 N_("Specify that ALIAS is an abbreviation of COMMAND.\n\
1751 Abbreviations are not used in command completion."),
1756 /* Create an option_def_group for the "alias" options, with
1757 A_OPTS as context. */
1759 static gdb::option::option_def_group
1760 make_alias_options_def_group (alias_opts
*a_opts
)
1762 return {{alias_option_defs
}, a_opts
};
1765 /* Completer for the "alias_command". */
1768 alias_command_completer (struct cmd_list_element
*ignore
,
1769 completion_tracker
&tracker
,
1770 const char *text
, const char *word
)
1772 const auto grp
= make_alias_options_def_group (nullptr);
1774 tracker
.set_use_custom_word_point (true);
1776 if (gdb::option::complete_options
1777 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
))
1780 const char *delim
= strchr (text
, '=');
1782 /* If we're past the "=" delimiter, complete the
1783 "alias ALIAS = COMMAND [DEFAULT-ARGS...]" as if the user is
1784 typing COMMAND DEFAULT-ARGS... */
1787 && isspace (delim
[-1])
1788 && (isspace (delim
[1]) || delim
[1] == '\0'))
1790 std::string new_text
= std::string (delim
+ 1);
1792 tracker
.advance_custom_word_point_by (delim
+ 1 - text
);
1793 complete_nested_command_line (tracker
, new_text
.c_str ());
1797 /* We're not yet past the "=" delimiter. Complete a command, as
1798 the user might type an alias following a prefix command. */
1799 complete_nested_command_line (tracker
, text
);
1802 /* Subroutine of alias_command to simplify it.
1803 Return the first N elements of ARGV flattened back to a string
1804 with a space separating each element.
1805 ARGV may not be NULL.
1806 This does not take care of quoting elements in case they contain spaces
1810 argv_to_string (char **argv
, int n
)
1815 gdb_assert (argv
!= NULL
);
1816 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1818 for (i
= 0; i
< n
; ++i
)
1828 /* Subroutine of alias_command to simplify it.
1829 Verifies that COMMAND can have an alias:
1831 COMMAND must not have default args.
1832 This last condition is to avoid the following:
1833 alias aaa = backtrace -full
1834 alias bbb = aaa -past-main
1835 as (at least currently), alias default args are not cumulative
1836 and the user would expect bbb to execute 'backtrace -full -past-main'
1837 while it will execute 'backtrace -past-main'. */
1839 static cmd_list_element
*
1840 validate_aliased_command (const char *command
)
1842 std::string default_args
;
1844 = lookup_cmd_1 (& command
, cmdlist
, NULL
, &default_args
, 1);
1846 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1847 error (_("Invalid command to alias to: %s"), command
);
1849 if (!default_args
.empty ())
1850 error (_("Cannot define an alias of an alias that has default args"));
1855 /* Called when "alias" was incorrectly used. */
1858 alias_usage_error (void)
1860 error (_("Usage: alias [-a] [--] ALIAS = COMMAND [DEFAULT-ARGS...]"));
1863 /* Make an alias of an existing command. */
1866 alias_command (const char *args
, int from_tty
)
1870 auto grp
= make_alias_options_def_group (&a_opts
);
1871 gdb::option::process_options
1872 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
);
1874 int i
, alias_argc
, command_argc
;
1876 const char *alias
, *command
;
1878 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1879 alias_usage_error ();
1881 equals
= strchr (args
, '=');
1882 std::string
args2 (args
, equals
- args
);
1884 gdb_argv
built_alias_argv (args2
.c_str ());
1886 const char *default_args
= equals
+ 1;
1887 struct cmd_list_element
*c_command_prefix
;
1889 lookup_cmd_for_default_args (&default_args
, &c_command_prefix
);
1890 std::string
command_argv_str (equals
+ 1,
1891 default_args
== nullptr
1892 ? strlen (equals
+ 1)
1893 : default_args
- equals
- 1);
1894 gdb_argv
command_argv (command_argv_str
.c_str ());
1896 char **alias_argv
= built_alias_argv
.get ();
1898 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1899 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1900 alias_usage_error ();
1902 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1904 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1907 error (_("Invalid command name: %s"), alias_argv
[i
]);
1909 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1913 alias_argc
= countargv (alias_argv
);
1914 command_argc
= command_argv
.count ();
1916 /* COMMAND must exist, and cannot have default args.
1917 Reconstruct the command to remove any extraneous spaces,
1918 for better error messages. */
1919 std::string
command_string (argv_to_string (command_argv
.get (),
1921 command
= command_string
.c_str ();
1922 cmd_list_element
*target_cmd
= validate_aliased_command (command
);
1924 /* ALIAS must not exist. */
1925 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1926 alias
= alias_string
.c_str ();
1928 cmd_list_element
*alias_cmd
, *prefix_cmd
, *cmd
;
1930 if (lookup_cmd_composition (alias
, &alias_cmd
, &prefix_cmd
, &cmd
))
1932 const char *alias_name
= alias_argv
[alias_argc
-1];
1934 /* If we found an existing ALIAS_CMD, check that the prefix differ or
1937 if (alias_cmd
!= nullptr
1938 && alias_cmd
->prefix
== prefix_cmd
1939 && strcmp (alias_name
, alias_cmd
->name
) == 0)
1940 error (_("Alias already exists: %s"), alias
);
1942 /* Check ALIAS differs from the found CMD. */
1944 if (cmd
->prefix
== prefix_cmd
1945 && strcmp (alias_name
, cmd
->name
) == 0)
1946 error (_("Alias %s is the name of an existing command"), alias
);
1951 struct cmd_list_element
*alias_cmd
;
1953 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1954 Example: alias spe = set print elements
1956 Otherwise ALIAS and COMMAND must have the same number of words,
1957 and every word except the last must identify the same prefix command;
1958 and the last word of ALIAS is made an alias of the last word of COMMAND.
1959 Example: alias set print elms = set pr elem
1960 Note that unambiguous abbreviations are allowed. */
1962 if (alias_argc
== 1)
1964 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1965 alias_cmd
= add_com_alias (xstrdup (alias_argv
[0]), target_cmd
,
1966 class_alias
, a_opts
.abbrev_flag
);
1970 const char *alias_prefix
, *command_prefix
;
1971 struct cmd_list_element
*c_alias
, *c_command
;
1973 if (alias_argc
!= command_argc
)
1974 error (_("Mismatched command length between ALIAS and COMMAND."));
1976 /* Create copies of ALIAS and COMMAND without the last word,
1977 and use that to verify the leading elements give the same
1979 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1981 std::string
command_prefix_string (argv_to_string (command_argv
.get (),
1983 alias_prefix
= alias_prefix_string
.c_str ();
1984 command_prefix
= command_prefix_string
.c_str ();
1986 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, NULL
, 1);
1987 /* We've already tried to look up COMMAND. */
1988 gdb_assert (c_command
!= NULL
1989 && c_command
!= (struct cmd_list_element
*) -1);
1990 gdb_assert (c_command
->is_prefix ());
1991 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, NULL
, 1);
1992 if (c_alias
!= c_command
)
1993 error (_("ALIAS and COMMAND prefixes do not match."));
1995 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1996 alias_cmd
= add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1997 target_cmd
, class_alias
, a_opts
.abbrev_flag
,
1998 c_command
->subcommands
);
2001 gdb_assert (alias_cmd
!= nullptr);
2002 gdb_assert (alias_cmd
->default_args
.empty ());
2003 if (default_args
!= nullptr)
2005 default_args
= skip_spaces (default_args
);
2007 alias_cmd
->default_args
= default_args
;
2011 /* Print the file / line number / symbol name of the location
2012 specified by SAL. */
2015 print_sal_location (const symtab_and_line
&sal
)
2017 scoped_restore_current_program_space restore_pspace
;
2018 set_current_program_space (sal
.pspace
);
2020 const char *sym_name
= NULL
;
2021 if (sal
.symbol
!= NULL
)
2022 sym_name
= sal
.symbol
->print_name ();
2023 gdb_printf (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
2024 symtab_to_filename_for_display (sal
.symtab
),
2025 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
2028 /* Print a list of files and line numbers which a user may choose from
2029 in order to list a function which was specified ambiguously (as
2030 with `list classname::overloadedfuncname', for example). The SALS
2031 array provides the filenames and line numbers. FORMAT is a
2032 printf-style format string used to tell the user what was
2036 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
2037 const char *format
, ...)
2040 va_start (ap
, format
);
2041 gdb_vprintf (format
, ap
);
2044 for (const auto &sal
: sals
)
2045 print_sal_location (sal
);
2048 /* Comparison function for filter_sals. Returns a qsort-style
2052 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
2054 const char *dira
= sala
.symtab
->compunit ()->dirname ();
2055 const char *dirb
= salb
.symtab
->compunit ()->dirname ();
2063 else if (dirb
== NULL
)
2070 r
= filename_cmp (dira
, dirb
);
2075 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
2079 if (sala
.line
< salb
.line
)
2081 return sala
.line
== salb
.line
? 0 : 1;
2084 /* Remove any SALs that do not match the current program space, or
2085 which appear to be "file:line" duplicates. */
2088 filter_sals (std::vector
<symtab_and_line
> &sals
)
2090 /* Remove SALs that do not match. */
2091 auto from
= std::remove_if (sals
.begin (), sals
.end (),
2092 [&] (const symtab_and_line
&sal
)
2093 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
2096 std::sort (sals
.begin (), from
,
2097 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
2098 { return cmp_symtabs (sala
, salb
) < 0; });
2100 from
= std::unique (sals
.begin (), from
,
2101 [&] (const symtab_and_line
&sala
,
2102 const symtab_and_line
&salb
)
2103 { return cmp_symtabs (sala
, salb
) == 0; });
2105 sals
.erase (from
, sals
.end ());
2109 init_cmd_lists (void)
2111 max_user_call_depth
= 1024;
2115 show_info_verbose (struct ui_file
*file
, int from_tty
,
2116 struct cmd_list_element
*c
,
2121 _("Verbose printing of informational messages is %s.\n"),
2124 gdb_printf (file
, _("Verbosity is %s.\n"), value
);
2128 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
2129 struct cmd_list_element
*c
, const char *value
)
2131 gdb_printf (file
, _("History expansion on command input is %s.\n"),
2136 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
2137 struct cmd_list_element
*c
, const char *value
)
2140 _("The max call depth for user-defined commands is %s.\n"),
2144 /* Implement 'show suppress-cli-notifications'. */
2147 show_suppress_cli_notifications (ui_file
*file
, int from_tty
,
2148 cmd_list_element
*c
, const char *value
)
2150 gdb_printf (file
, _("Suppression of printing CLI notifications "
2151 "is %s.\n"), value
);
2154 /* Implement 'set suppress-cli-notifications'. */
2157 set_suppress_cli_notifications (const char *args
, int from_tty
,
2158 cmd_list_element
*c
)
2160 cli_suppress_notification
.user_selected_context
2161 = user_wants_cli_suppress_notification
;
2162 cli_suppress_notification
.normal_stop
2163 = user_wants_cli_suppress_notification
;
2166 /* Returns the cmd_list_element in SHOWLIST corresponding to the first
2167 argument of ARGV, which must contain one single value.
2168 Throws an error if no value provided, or value not correct.
2169 FNNAME is used in the error message. */
2171 static cmd_list_element
*
2172 setting_cmd (const char *fnname
, struct cmd_list_element
*showlist
,
2173 int argc
, struct value
**argv
)
2176 error (_("You must provide an argument to %s"), fnname
);
2178 error (_("You can only provide one argument to %s"), fnname
);
2180 struct type
*type0
= check_typedef (value_type (argv
[0]));
2182 if (type0
->code () != TYPE_CODE_ARRAY
2183 && type0
->code () != TYPE_CODE_STRING
)
2184 error (_("First argument of %s must be a string."), fnname
);
2186 const char *a0
= (const char *) value_contents (argv
[0]).data ();
2187 cmd_list_element
*cmd
= lookup_cmd (&a0
, showlist
, "", NULL
, -1, 0);
2189 if (cmd
== nullptr || cmd
->type
!= show_cmd
)
2190 error (_("First argument of %s must be a "
2191 "valid setting of the 'show' command."), fnname
);
2196 /* Builds a value from the show CMD. */
2198 static struct value
*
2199 value_from_setting (const setting
&var
, struct gdbarch
*gdbarch
)
2201 switch (var
.type ())
2204 if (var
.get
<int> () == INT_MAX
)
2205 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2208 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2211 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2214 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2215 var
.get
<bool> () ? 1 : 0);
2216 case var_zuinteger_unlimited
:
2217 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2219 case var_auto_boolean
:
2223 switch (var
.get
<enum auto_boolean
> ())
2225 case AUTO_BOOLEAN_TRUE
:
2228 case AUTO_BOOLEAN_FALSE
:
2231 case AUTO_BOOLEAN_AUTO
:
2235 gdb_assert_not_reached ("invalid var_auto_boolean");
2237 return value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2241 if (var
.get
<unsigned int> () == UINT_MAX
)
2242 return value_from_ulongest
2243 (builtin_type (gdbarch
)->builtin_unsigned_int
, 0);
2245 return value_from_ulongest
2246 (builtin_type (gdbarch
)->builtin_unsigned_int
,
2247 var
.get
<unsigned int> ());
2249 return value_from_ulongest (builtin_type (gdbarch
)->builtin_unsigned_int
,
2250 var
.get
<unsigned int> ());
2252 case var_string_noescape
:
2253 case var_optional_filename
:
2259 if (var
.type () == var_enum
)
2261 value
= var
.get
<const char *> ();
2262 len
= strlen (value
);
2266 const std::string
&st
= var
.get
<std::string
> ();
2267 value
= st
.c_str ();
2272 return value_cstring (value
, len
,
2273 builtin_type (gdbarch
)->builtin_char
);
2275 return value_cstring ("", 1,
2276 builtin_type (gdbarch
)->builtin_char
);
2279 gdb_assert_not_reached ("bad var_type");
2283 /* Implementation of the convenience function $_gdb_setting. */
2285 static struct value
*
2286 gdb_setting_internal_fn (struct gdbarch
*gdbarch
,
2287 const struct language_defn
*language
,
2288 void *cookie
, int argc
, struct value
**argv
)
2290 cmd_list_element
*show_cmd
2291 = setting_cmd ("$_gdb_setting", showlist
, argc
, argv
);
2293 gdb_assert (show_cmd
->var
.has_value ());
2295 return value_from_setting (*show_cmd
->var
, gdbarch
);
2298 /* Implementation of the convenience function $_gdb_maint_setting. */
2300 static struct value
*
2301 gdb_maint_setting_internal_fn (struct gdbarch
*gdbarch
,
2302 const struct language_defn
*language
,
2303 void *cookie
, int argc
, struct value
**argv
)
2305 cmd_list_element
*show_cmd
2306 = setting_cmd ("$_gdb_maint_setting", maintenance_show_cmdlist
, argc
, argv
);
2308 gdb_assert (show_cmd
->var
.has_value ());
2310 return value_from_setting (*show_cmd
->var
, gdbarch
);
2313 /* Builds a string value from the show CMD. */
2315 static struct value
*
2316 str_value_from_setting (const setting
&var
, struct gdbarch
*gdbarch
)
2318 switch (var
.type ())
2323 case var_zuinteger_unlimited
:
2324 case var_auto_boolean
:
2328 std::string cmd_val
= get_setshow_command_value_string (var
);
2330 return value_cstring (cmd_val
.c_str (), cmd_val
.size (),
2331 builtin_type (gdbarch
)->builtin_char
);
2335 case var_string_noescape
:
2336 case var_optional_filename
:
2339 /* For these cases, we do not use get_setshow_command_value_string,
2340 as this function handle some characters specially, e.g. by
2341 escaping quotevar. So, we directly use the var string value,
2342 similarly to the value_from_setting code for these casevar. */
2346 if (var
.type () == var_enum
)
2348 value
= var
.get
<const char *> ();
2349 len
= strlen (value
);
2353 const std::string
&st
= var
.get
<std::string
> ();
2354 value
= st
.c_str ();
2359 return value_cstring (value
, len
,
2360 builtin_type (gdbarch
)->builtin_char
);
2362 return value_cstring ("", 1,
2363 builtin_type (gdbarch
)->builtin_char
);
2366 gdb_assert_not_reached ("bad var_type");
2370 /* Implementation of the convenience function $_gdb_setting_str. */
2372 static struct value
*
2373 gdb_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2374 const struct language_defn
*language
,
2375 void *cookie
, int argc
, struct value
**argv
)
2377 cmd_list_element
*show_cmd
2378 = setting_cmd ("$_gdb_setting_str", showlist
, argc
, argv
);
2380 gdb_assert (show_cmd
->var
.has_value ());
2382 return str_value_from_setting (*show_cmd
->var
, gdbarch
);
2386 /* Implementation of the convenience function $_gdb_maint_setting_str. */
2388 static struct value
*
2389 gdb_maint_setting_str_internal_fn (struct gdbarch
*gdbarch
,
2390 const struct language_defn
*language
,
2391 void *cookie
, int argc
, struct value
**argv
)
2393 cmd_list_element
*show_cmd
2394 = setting_cmd ("$_gdb_maint_setting_str", maintenance_show_cmdlist
, argc
,
2397 gdb_assert (show_cmd
->var
.has_value ());
2399 return str_value_from_setting (*show_cmd
->var
, gdbarch
);
2402 void _initialize_cli_cmds ();
2404 _initialize_cli_cmds ()
2406 struct cmd_list_element
*c
;
2408 /* Define the classes of commands.
2409 They will appear in the help list in alphabetical order. */
2411 add_cmd ("internals", class_maintenance
, _("\
2412 Maintenance commands.\n\
2413 Some gdb commands are provided just for use by gdb maintainers.\n\
2414 These commands are subject to frequent change, and may not be as\n\
2415 well documented as user commands."),
2417 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
2418 add_cmd ("aliases", class_alias
,
2419 _("User-defined aliases of other commands."), &cmdlist
);
2420 add_cmd ("user-defined", class_user
, _("\
2421 User-defined commands.\n\
2422 The commands in this class are those defined by the user.\n\
2423 Use the \"define\" command to define a command."), &cmdlist
);
2424 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
2425 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
2426 add_cmd ("files", class_files
, _("Specifying and examining files."),
2428 add_cmd ("breakpoints", class_breakpoint
,
2429 _("Making program stop at certain points."), &cmdlist
);
2430 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
2431 add_cmd ("stack", class_stack
, _("\
2432 Examining the stack.\n\
2433 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
2434 counting from zero for the innermost (currently executing) frame.\n\n\
2435 At any time gdb identifies one frame as the \"selected\" frame.\n\
2436 Variable lookups are done with respect to the selected frame.\n\
2437 When the program being debugged stops, gdb selects the innermost frame.\n\
2438 The commands below can be used to select other frames by number or address."),
2441 add_cmd ("text-user-interface", class_tui
,
2442 _("TUI is the GDB text based interface.\n\
2443 In TUI mode, GDB can display several text windows showing\n\
2444 the source file, the processor registers, the program disassembly, ..."), &cmdlist
);
2446 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
2448 /* Define general commands. */
2450 add_com ("pwd", class_files
, pwd_command
, _("\
2451 Print working directory.\n\
2452 This is used for your program as well."));
2454 c
= add_cmd ("cd", class_files
, cd_command
, _("\
2455 Set working directory to DIR for debugger.\n\
2456 The debugger's current working directory specifies where scripts and other\n\
2457 files that can be loaded by GDB are located.\n\
2458 In order to change the inferior's current working directory, the recommended\n\
2459 way is to use the \"set cwd\" command."), &cmdlist
);
2460 set_cmd_completer (c
, filename_completer
);
2462 add_com ("echo", class_support
, echo_command
, _("\
2463 Print a constant string. Give string as argument.\n\
2464 C escape sequences may be used in the argument.\n\
2465 No newline is added at the end of the argument;\n\
2466 use \"\\n\" if you want a newline to be printed.\n\
2467 Since leading and trailing whitespace are ignored in command arguments,\n\
2468 if you want to print some you must use \"\\\" before leading whitespace\n\
2469 to be printed or after trailing whitespace."));
2471 add_setshow_enum_cmd ("script-extension", class_support
,
2472 script_ext_enums
, &script_ext_mode
, _("\
2473 Set mode for script filename extension recognition."), _("\
2474 Show mode for script filename extension recognition."), _("\
2475 off == no filename extension recognition (all sourced files are GDB scripts)\n\
2476 soft == evaluate script according to filename extension, fallback to GDB script"
2478 strict == evaluate script according to filename extension, error if not supported"
2481 show_script_ext_mode
,
2482 &setlist
, &showlist
);
2484 cmd_list_element
*quit_cmd
2485 = add_com ("quit", class_support
, quit_command
, _("\
2487 Usage: quit [EXPR] or exit [EXPR]\n\
2488 The optional expression EXPR, if present, is evaluated and the result\n\
2489 used as GDB's exit code. The default is zero."));
2490 cmd_list_element
*help_cmd
2491 = add_com ("help", class_support
, help_command
,
2492 _("Print list of commands."));
2493 set_cmd_completer (help_cmd
, command_completer
);
2494 add_com_alias ("q", quit_cmd
, class_support
, 1);
2495 add_com_alias ("exit", quit_cmd
, class_support
, 1);
2496 add_com_alias ("h", help_cmd
, class_support
, 1);
2498 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
2499 Set verbosity."), _("\
2500 Show verbosity."), NULL
,
2503 &setlist
, &showlist
);
2505 add_setshow_prefix_cmd
2506 ("history", class_support
,
2507 _("Generic command for setting command history parameters."),
2508 _("Generic command for showing command history parameters."),
2509 &sethistlist
, &showhistlist
, &setlist
, &showlist
);
2511 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
2512 Set history expansion on command input."), _("\
2513 Show history expansion on command input."), _("\
2514 Without an argument, history expansion is enabled."),
2516 show_history_expansion_p
,
2517 &sethistlist
, &showhistlist
);
2519 cmd_list_element
*info_cmd
2520 = add_prefix_cmd ("info", class_info
, info_command
, _("\
2521 Generic command for showing things about the program being debugged."),
2522 &infolist
, 0, &cmdlist
);
2523 add_com_alias ("i", info_cmd
, class_info
, 1);
2524 add_com_alias ("inf", info_cmd
, class_info
, 1);
2526 add_com ("complete", class_obscure
, complete_command
,
2527 _("List the completions for the rest of the line as a command."));
2529 c
= add_show_prefix_cmd ("show", class_info
, _("\
2530 Generic command for showing things about the debugger."),
2531 &showlist
, 0, &cmdlist
);
2532 /* Another way to get at the same thing. */
2533 add_alias_cmd ("set", c
, class_info
, 0, &infolist
);
2535 cmd_list_element
*with_cmd
2536 = add_com ("with", class_vars
, with_command
, _("\
2537 Temporarily set SETTING to VALUE, run COMMAND, and restore SETTING.\n\
2538 Usage: with SETTING [VALUE] [-- COMMAND]\n\
2539 Usage: w SETTING [VALUE] [-- COMMAND]\n\
2540 With no COMMAND, repeats the last executed command.\n\
2542 SETTING is any setting you can change with the \"set\" subcommands.\n\
2544 with language pascal -- print obj\n\
2545 with print elements unlimited -- print obj\n\
2547 You can change multiple settings using nested with, and use\n\
2548 abbreviations for commands and/or values. E.g.:\n\
2549 w la p -- w p el u -- p obj"));
2550 set_cmd_completer_handle_brkchars (with_cmd
, with_command_completer
);
2551 add_com_alias ("w", with_cmd
, class_vars
, 1);
2553 add_internal_function ("_gdb_setting_str", _("\
2554 $_gdb_setting_str - returns the value of a GDB setting as a string.\n\
2555 Usage: $_gdb_setting_str (setting)\n\
2557 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2558 boolean values are \"off\", \"on\".\n\
2559 Some integer settings accept an unlimited value, returned\n\
2560 as \"unlimited\"."),
2561 gdb_setting_str_internal_fn
, NULL
);
2563 add_internal_function ("_gdb_setting", _("\
2564 $_gdb_setting - returns the value of a GDB setting.\n\
2565 Usage: $_gdb_setting (setting)\n\
2566 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2567 boolean values are \"off\", \"on\".\n\
2568 Some integer settings accept an unlimited value, returned\n\
2569 as 0 or -1 depending on the setting."),
2570 gdb_setting_internal_fn
, NULL
);
2572 add_internal_function ("_gdb_maint_setting_str", _("\
2573 $_gdb_maint_setting_str - returns the value of a GDB maintenance setting as a string.\n\
2574 Usage: $_gdb_maint_setting_str (setting)\n\
2576 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2577 boolean values are \"off\", \"on\".\n\
2578 Some integer settings accept an unlimited value, returned\n\
2579 as \"unlimited\"."),
2580 gdb_maint_setting_str_internal_fn
, NULL
);
2582 add_internal_function ("_gdb_maint_setting", _("\
2583 $_gdb_maint_setting - returns the value of a GDB maintenance setting.\n\
2584 Usage: $_gdb_maint_setting (setting)\n\
2585 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2586 boolean values are \"off\", \"on\".\n\
2587 Some integer settings accept an unlimited value, returned\n\
2588 as 0 or -1 depending on the setting."),
2589 gdb_maint_setting_internal_fn
, NULL
);
2591 add_cmd ("commands", no_set_class
, show_commands
, _("\
2592 Show the history of commands you typed.\n\
2593 You can supply a command number to start with, or a `+' to start after\n\
2594 the previous command number shown."),
2597 add_cmd ("version", no_set_class
, show_version
,
2598 _("Show what version of GDB this is."), &showlist
);
2600 add_cmd ("configuration", no_set_class
, show_configuration
,
2601 _("Show how GDB was configured at build time."), &showlist
);
2603 add_setshow_prefix_cmd ("debug", no_class
,
2604 _("Generic command for setting gdb debugging flags."),
2605 _("Generic command for showing gdb debugging flags."),
2606 &setdebuglist
, &showdebuglist
,
2607 &setlist
, &showlist
);
2609 cmd_list_element
*shell_cmd
2610 = add_com ("shell", class_support
, shell_command
, _("\
2611 Execute the rest of the line as a shell command.\n\
2612 With no arguments, run an inferior shell."));
2613 set_cmd_completer (shell_cmd
, filename_completer
);
2615 add_com_alias ("!", shell_cmd
, class_support
, 0);
2617 c
= add_com ("edit", class_files
, edit_command
, _("\
2618 Edit specified file or function.\n\
2619 With no argument, edits file containing most recent line listed.\n\
2620 Editing targets can be specified in these ways:\n\
2621 FILE:LINENUM, to edit at that line in that file,\n\
2622 FUNCTION, to edit at the beginning of that function,\n\
2623 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2624 *ADDRESS, to edit at the line containing that address.\n\
2625 Uses EDITOR environment variable contents as editor (or ex as default)."));
2627 c
->completer
= location_completer
;
2629 cmd_list_element
*pipe_cmd
2630 = add_com ("pipe", class_support
, pipe_command
, _("\
2631 Send the output of a gdb command to a shell command.\n\
2632 Usage: | [COMMAND] | SHELL_COMMAND\n\
2633 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2634 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
2635 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2637 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
2639 The -d option indicates to use the string DELIM to separate COMMAND\n\
2640 from SHELL_COMMAND, in alternative to |. This is useful in\n\
2641 case COMMAND contains a | character.\n\
2643 With no COMMAND, repeat the last executed command\n\
2644 and send its output to SHELL_COMMAND."));
2645 set_cmd_completer_handle_brkchars (pipe_cmd
, pipe_command_completer
);
2646 add_com_alias ("|", pipe_cmd
, class_support
, 0);
2648 cmd_list_element
*list_cmd
2649 = add_com ("list", class_files
, list_command
, _("\
2650 List specified function or line.\n\
2651 With no argument, lists ten more lines after or around previous listing.\n\
2652 \"list -\" lists the ten lines before a previous ten-line listing.\n\
2653 One argument specifies a line, and ten lines are listed around that line.\n\
2654 Two arguments with comma between specify starting and ending lines to list.\n\
2655 Lines can be specified in these ways:\n\
2656 LINENUM, to list around that line in current file,\n\
2657 FILE:LINENUM, to list around that line in that file,\n\
2658 FUNCTION, to list around beginning of that function,\n\
2659 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2660 *ADDRESS, to list around the line containing that address.\n\
2661 With two args, if one is empty, it stands for ten lines away from\n\
2664 By default, when a single location is given, display ten lines.\n\
2665 This can be changed using \"set listsize\", and the current value\n\
2666 can be shown using \"show listsize\"."));
2668 add_com_alias ("l", list_cmd
, class_files
, 1);
2670 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
2671 Disassemble a specified section of memory.\n\
2672 Usage: disassemble[/m|/r|/s] START [, END]\n\
2673 Default is the function surrounding the pc of the selected frame.\n\
2675 With a /s modifier, source lines are included (if available).\n\
2676 In this mode, the output is displayed in PC address order, and\n\
2677 file names and contents for all relevant source files are displayed.\n\
2679 With a /m modifier, source lines are included (if available).\n\
2680 This view is \"source centric\": the output is in source line order,\n\
2681 regardless of any optimization that is present. Only the main source file\n\
2682 is displayed, not those of, e.g., any inlined functions.\n\
2683 This modifier hasn't proved useful in practice and is deprecated\n\
2686 With a /r modifier, raw instructions in hex are included.\n\
2688 With a single argument, the function surrounding that address is dumped.\n\
2689 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
2690 in the form of \"start,end\", or \"start,+length\".\n\
2692 Note that the address is interpreted as an expression, not as a location\n\
2693 like in the \"break\" command.\n\
2694 So, for example, if you want to disassemble function bar in file foo.c\n\
2695 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
2696 set_cmd_completer (c
, location_completer
);
2698 c
= add_com ("make", class_support
, make_command
, _("\
2699 Run the ``make'' program using the rest of the line as arguments."));
2700 set_cmd_completer (c
, filename_completer
);
2701 c
= add_cmd ("user", no_class
, show_user
, _("\
2702 Show definitions of non-python/scheme user defined commands.\n\
2703 Argument is the name of the user defined command.\n\
2704 With no argument, show definitions of all user defined commands."), &showlist
);
2705 set_cmd_completer (c
, show_user_completer
);
2706 add_com ("apropos", class_support
, apropos_command
, _("\
2707 Search for commands matching a REGEXP.\n\
2708 Usage: apropos [-v] REGEXP\n\
2709 Flag -v indicates to produce a verbose output, showing full documentation\n\
2710 of the matching commands."));
2712 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
2713 &max_user_call_depth
, _("\
2714 Set the max call depth for non-python/scheme user-defined commands."), _("\
2715 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
2717 show_max_user_call_depth
,
2718 &setlist
, &showlist
);
2720 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
2721 Set tracing of GDB CLI commands."), _("\
2722 Show state of GDB CLI command tracing."), _("\
2723 When 'on', each command is displayed as it is executed."),
2726 &setlist
, &showlist
);
2728 const auto alias_opts
= make_alias_options_def_group (nullptr);
2730 static std::string alias_help
2731 = gdb::option::build_help (_("\
2732 Define a new command that is an alias of an existing command.\n\
2733 Usage: alias [-a] [--] ALIAS = COMMAND [DEFAULT-ARGS...]\n\
2734 ALIAS is the name of the alias command to create.\n\
2735 COMMAND is the command being aliased to.\n\
2740 GDB will automatically prepend the provided DEFAULT-ARGS to the list\n\
2741 of arguments explicitly provided when using ALIAS.\n\
2742 Use \"help aliases\" to list all user defined aliases and their default args.\n\
2745 Make \"spe\" an alias of \"set print elements\":\n\
2746 alias spe = set print elements\n\
2747 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2748 alias -a set print elms = set print elements\n\
2749 Make \"btf\" an alias of \"backtrace -full -past-entry -past-main\" :\n\
2750 alias btf = backtrace -full -past-entry -past-main\n\
2751 Make \"wLapPeu\" an alias of 2 nested \"with\":\n\
2752 alias wLapPeu = with language pascal -- with print elements unlimited --"),
2755 c
= add_com ("alias", class_support
, alias_command
,
2756 alias_help
.c_str ());
2758 set_cmd_completer_handle_brkchars (c
, alias_command_completer
);
2760 add_setshow_boolean_cmd ("suppress-cli-notifications", no_class
,
2761 &user_wants_cli_suppress_notification
,
2763 Set whether printing notifications on CLI is suppressed."), _("\
2764 Show whether printing notifications on CLI is suppressed."), _("\
2765 When on, printing notifications (such as inferior/thread switch)\n\
2766 on CLI is suppressed."),
2767 set_suppress_cli_notifications
,
2768 show_suppress_cli_notifications
,
2772 const char *source_help_text
= xstrprintf (_("\
2773 Read commands from a file named FILE.\n\
2775 Usage: source [-s] [-v] FILE\n\
2776 -s: search for the script in the source search path,\n\
2777 even if FILE contains directories.\n\
2778 -v: each command in FILE is echoed as it is executed.\n\
2780 Note that the file \"%s\" is read automatically in this way\n\
2781 when GDB is started."), GDBINIT
).release ();
2782 c
= add_cmd ("source", class_support
, source_command
,
2783 source_help_text
, &cmdlist
);
2784 set_cmd_completer (c
, filename_completer
);