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 gdb::unique_xmalloc_ptr<char> tilde_expanded_file;
754 file_to_open = opened->full_path.get ();
757 tilde_expanded_file = gdb_tilde_expand_up (file);
758 file_to_open = tilde_expanded_file.get ();
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_stdout->wrap_here (0);
850 gdb_flush (gdb_stdout);
853 /* Sets the last launched shell command convenience variables based on
857 exit_status_set_internal_vars (int exit_status)
859 struct internalvar *var_code = lookup_internalvar ("_shell_exitcode");
860 struct internalvar *var_signal = lookup_internalvar ("_shell_exitsignal");
862 clear_internalvar (var_code);
863 clear_internalvar (var_signal);
864 if (WIFEXITED (exit_status))
865 set_internalvar_integer (var_code, WEXITSTATUS (exit_status));
867 else if (WIFSIGNALED (exit_status) && WTERMSIG (exit_status) == -1)
869 /* The -1 condition can happen on MinGW, if we don't recognize
870 the fatal exception code encoded in the exit status; see
871 gdbsupport/gdb_wait.c. We don't want to lose information in
872 the exit status in that case. Record it as a normal exit
873 with the full exit status, including the higher 0xC0000000
875 set_internalvar_integer (var_code, exit_status);
878 else if (WIFSIGNALED (exit_status))
879 set_internalvar_integer (var_signal, WTERMSIG (exit_status));
881 warning (_("unexpected shell command exit status %d"), exit_status);
885 shell_escape (const char *arg, int from_tty)
887 #if defined(CANT_FORK) || \
888 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
889 /* If ARG is NULL, they want an inferior shell, but `system' just
890 reports if the shell is available when passed a NULL arg. */
891 int rc = system (arg ? arg : "");
894 arg = "inferior shell";
897 gdb_printf (gdb_stderr, "Cannot execute %s: %s\n", arg,
898 safe_strerror (errno));
900 gdb_printf (gdb_stderr, "%s exited with status %d\n", arg, rc);
902 /* Make sure to return to the directory GDB thinks it is, in case
903 the shell command we just ran changed it. */
904 chdir (current_directory);
906 exit_status_set_internal_vars (rc);
907 #else /* Can fork. */
910 if ((pid = vfork ()) == 0)
912 const char *p, *user_shell = get_shell ();
916 /* Get the name of the shell for arg0. */
917 p = lbasename (user_shell);
920 execl (user_shell, p, (char *) 0);
922 execl (user_shell, p, "-c", arg, (char *) 0);
924 gdb_printf (gdb_stderr, "Cannot execute %s: %s\n", user_shell,
925 safe_strerror (errno));
930 waitpid (pid, &status, 0);
932 error (_("Fork failed"));
933 exit_status_set_internal_vars (status);
934 #endif /* Can fork. */
937 /* Implementation of the "shell" command. */
940 shell_command (const char *arg, int from_tty)
942 shell_escape (arg, from_tty);
946 edit_command (const char *arg, int from_tty)
948 struct symtab_and_line sal;
953 /* Pull in the current default source line if necessary. */
956 set_default_source_symtab_and_line ();
957 sal = get_current_source_symtab_and_line ();
960 /* Bare "edit" edits file with present line. */
965 error (_("No default source file yet."));
966 sal.line += get_lines_to_list () / 2;
972 /* Now should only be one argument -- decode it in SAL. */
974 event_location_up location = string_to_event_location (&arg1,
978 error (_("Junk at end of line specification."));
980 std::vector<symtab_and_line> sals = decode_line_1 (location.get (),
981 DECODE_LINE_LIST_MODE,
990 if (sals.size () > 1)
992 ambiguous_line_spec (sals,
993 _("Specified line is ambiguous:\n"));
999 /* If line was specified by address, first print exactly which
1000 line, and which file. In this case, sal.symtab == 0 means
1001 address is outside of all known source files, not that user
1002 failed to give a filename. */
1005 struct gdbarch *gdbarch;
1007 if (sal.symtab == 0)
1008 error (_("No source file for address %s."),
1009 paddress (get_current_arch (), sal.pc));
1011 gdbarch = sal.symtab->objfile ()->arch ();
1012 sym = find_pc_function (sal.pc);
1014 gdb_printf ("%s is in %s (%s:%d).\n",
1015 paddress (gdbarch, sal.pc),
1017 symtab_to_filename_for_display (sal.symtab),
1020 gdb_printf ("%s is at %s:%d.\n",
1021 paddress (gdbarch, sal.pc),
1022 symtab_to_filename_for_display (sal.symtab),
1026 /* If what was given does not imply a symtab, it must be an
1027 undebuggable symbol which means no source code. */
1029 if (sal.symtab == 0)
1030 error (_("No line number known for %s."), arg);
1033 if ((editor = getenv ("EDITOR")) == NULL)
1036 fn = symtab_to_fullname (sal.symtab);
1038 /* Quote the file name, in case it has whitespace or other special
1040 gdb::unique_xmalloc_ptr<char> p
1041 = xstrprintf ("%s +%d \"%s\"", editor, sal.line, fn);
1042 shell_escape (p.get (), from_tty);
1045 /* The options for the "pipe" command. */
1047 struct pipe_cmd_opts
1050 std::string delimiter;
1053 static const gdb::option::option_def pipe_cmd_option_defs[] = {
1055 gdb::option::string_option_def<pipe_cmd_opts> {
1057 [] (pipe_cmd_opts *opts) { return &opts->delimiter; },
1059 N_("Indicates to use the specified delimiter string to separate\n\
1060 COMMAND from SHELL_COMMAND, in alternative to |. This is useful in\n\
1061 case COMMAND contains a | character."),
1066 /* Create an option_def_group for the "pipe" command's options, with
1069 static inline gdb::option::option_def_group
1070 make_pipe_cmd_options_def_group (pipe_cmd_opts *opts)
1072 return {{pipe_cmd_option_defs}, opts};
1075 /* Implementation of the "pipe" command. */
1078 pipe_command (const char *arg, int from_tty)
1082 auto grp = make_pipe_cmd_options_def_group (&opts);
1083 gdb::option::process_options
1084 (&arg, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
1086 const char *delim = "|";
1087 if (!opts.delimiter.empty ())
1088 delim = opts.delimiter.c_str ();
1090 const char *command = arg;
1091 if (command == nullptr)
1092 error (_("Missing COMMAND"));
1094 arg = strstr (arg, delim);
1097 error (_("Missing delimiter before SHELL_COMMAND"));
1099 std::string gdb_cmd (command, arg - command);
1101 arg += strlen (delim); /* Skip the delimiter. */
1103 if (gdb_cmd.empty ())
1104 gdb_cmd = repeat_previous ();
1106 const char *shell_command = skip_spaces (arg);
1107 if (*shell_command == '\0')
1108 error (_("Missing SHELL_COMMAND"));
1110 FILE *to_shell_command = popen (shell_command, "w");
1112 if (to_shell_command == nullptr)
1113 error (_("Error launching \"%s\""), shell_command);
1117 stdio_file pipe_file (to_shell_command);
1119 execute_command_to_ui_file (&pipe_file, gdb_cmd.c_str (), from_tty);
1123 pclose (to_shell_command);
1127 int exit_status = pclose (to_shell_command);
1129 if (exit_status < 0)
1130 error (_("shell command \"%s\" failed: %s"), shell_command,
1131 safe_strerror (errno));
1132 exit_status_set_internal_vars (exit_status);
1135 /* Completer for the pipe command. */
1138 pipe_command_completer (struct cmd_list_element *ignore,
1139 completion_tracker &tracker,
1140 const char *text, const char *word_ignored)
1144 const char *org_text = text;
1145 auto grp = make_pipe_cmd_options_def_group (&opts);
1146 if (gdb::option::complete_options
1147 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp))
1150 const char *delimiter = "|";
1151 if (!opts.delimiter.empty ())
1152 delimiter = opts.delimiter.c_str ();
1154 /* Check if we're past option values already. */
1155 if (text > org_text && !isspace (text[-1]))
1158 const char *delim = strstr (text, delimiter);
1160 /* If we're still not past the delimiter, complete the gdb
1162 if (delim == nullptr || delim == text)
1164 complete_nested_command_line (tracker, text);
1168 /* We're past the delimiter. What follows is a shell command, which
1169 we don't know how to complete. */
1173 list_command (const char *arg, int from_tty)
1180 int linenum_beg = 0;
1183 /* Pull in the current default source line if necessary. */
1184 if (arg == NULL || ((arg[0] == '+' || arg[0] == '-') && arg[1] == '\0'))
1186 set_default_source_symtab_and_line ();
1187 symtab_and_line cursal = get_current_source_symtab_and_line ();
1189 /* If this is the first "list" since we've set the current
1190 source line, center the listing around that line. */
1191 if (get_first_line_listed () == 0)
1195 first = std::max (cursal.line - get_lines_to_list () / 2, 1);
1197 /* A small special case --- if listing backwards, and we
1198 should list only one line, list the preceding line,
1199 instead of the exact line we've just shown after e.g.,
1200 stopping for a breakpoint. */
1201 if (arg != NULL && arg[0] == '-'
1202 && get_lines_to_list () == 1 && first > 1)
1205 print_source_lines (cursal.symtab, source_lines_range (first), 0);
1208 /* "l" or "l +" lists next ten lines. */
1209 else if (arg == NULL || arg[0] == '+')
1210 print_source_lines (cursal.symtab,
1211 source_lines_range (cursal.line), 0);
1213 /* "l -" lists previous ten lines, the ones before the ten just
1215 else if (arg[0] == '-')
1217 if (get_first_line_listed () == 1)
1218 error (_("Already at the start of %s."),
1219 symtab_to_filename_for_display (cursal.symtab));
1220 source_lines_range range (get_first_line_listed (),
1221 source_lines_range::BACKWARD);
1222 print_source_lines (cursal.symtab, range, 0);
1228 /* Now if there is only one argument, decode it in SAL
1230 If there are two arguments, decode them in SAL and SAL_END
1231 and clear NO_END; however, if one of the arguments is blank,
1232 set DUMMY_BEG or DUMMY_END to record that fact. */
1234 if (!have_full_symbols () && !have_partial_symbols ())
1235 error (_("No symbol table is loaded. Use the \"file\" command."));
1237 std::vector<symtab_and_line> sals;
1238 symtab_and_line sal, sal_end;
1245 event_location_up location = string_to_event_location (&arg1,
1248 /* We know that the ARG string is not empty, yet the attempt to parse
1249 a location from the string consumed no characters. This most
1250 likely means that the first thing in ARG looks like a location
1251 condition, and so the string_to_event_location call stopped
1254 error (_("Junk at end of line specification."));
1256 sals = decode_line_1 (location.get (), DECODE_LINE_LIST_MODE,
1268 /* Record whether the BEG arg is all digits. */
1270 for (p = arg; p != arg1 && *p >= '0' && *p <= '9'; p++);
1271 linenum_beg = (p == arg1);
1273 /* Save the range of the first argument, in case we need to let the
1274 user know it was ambiguous. */
1275 const char *beg = arg;
1276 size_t beg_len = arg1 - beg;
1278 while (*arg1 == ' ' || *arg1 == '\t')
1283 if (sals.size () > 1)
1285 ambiguous_line_spec (sals,
1286 _("Specified first line '%.*s' is ambiguous:\n"),
1287 (int) beg_len, beg);
1291 while (*arg1 == ' ' || *arg1 == '\t')
1297 /* Save the last argument, in case we need to let the user
1298 know it was ambiguous. */
1299 const char *end_arg = arg1;
1301 event_location_up location
1302 = string_to_event_location (&arg1, current_language);
1305 error (_("Junk at end of line specification."));
1307 std::vector<symtab_and_line> sals_end
1309 ? decode_line_1 (location.get (), DECODE_LINE_LIST_MODE,
1311 : decode_line_1 (location.get (), DECODE_LINE_LIST_MODE,
1312 NULL, sal.symtab, sal.line));
1314 filter_sals (sals_end);
1315 if (sals_end.empty ())
1317 if (sals_end.size () > 1)
1319 ambiguous_line_spec (sals_end,
1320 _("Specified last line '%s' is ambiguous:\n"),
1324 sal_end = sals_end[0];
1329 error (_("Junk at end of line specification."));
1331 if (!no_end && !dummy_beg && !dummy_end
1332 && sal.symtab != sal_end.symtab)
1333 error (_("Specified first and last lines are in different files."));
1334 if (dummy_beg && dummy_end)
1335 error (_("Two empty args do not say what lines to list."));
1337 /* If line was specified by address,
1338 first print exactly which line, and which file.
1340 In this case, sal.symtab == 0 means address is outside of all
1341 known source files, not that user failed to give a filename. */
1344 struct gdbarch *gdbarch;
1346 if (sal.symtab == 0)
1347 error (_("No source file for address %s."),
1348 paddress (get_current_arch (), sal.pc));
1350 gdbarch = sal.symtab->objfile ()->arch ();
1351 sym = find_pc_function (sal.pc);
1353 gdb_printf ("%s is in %s (%s:%d).\n",
1354 paddress (gdbarch, sal.pc),
1356 symtab_to_filename_for_display (sal.symtab), sal.line);
1358 gdb_printf ("%s is at %s:%d.\n",
1359 paddress (gdbarch, sal.pc),
1360 symtab_to_filename_for_display (sal.symtab), sal.line);
1363 /* If line was not specified by just a line number, and it does not
1364 imply a symtab, it must be an undebuggable symbol which means no
1367 if (!linenum_beg && sal.symtab == 0)
1368 error (_("No line number known for %s."), arg);
1370 /* If this command is repeated with RET,
1371 turn it into the no-arg variant. */
1374 set_repeat_arguments ("");
1376 if (dummy_beg && sal_end.symtab == 0)
1377 error (_("No default source file yet. Do \"help list\"."));
1380 source_lines_range range (sal_end.line + 1,
1381 source_lines_range::BACKWARD);
1382 print_source_lines (sal_end.symtab, range, 0);
1384 else if (sal.symtab == 0)
1385 error (_("No default source file yet. Do \"help list\"."));
1388 for (int i = 0; i < sals.size (); i++)
1391 int first_line = sal.line - get_lines_to_list () / 2;
1394 if (sals.size () > 1)
1395 print_sal_location (sal);
1396 print_source_lines (sal.symtab, source_lines_range (first_line), 0);
1400 print_source_lines (sal.symtab, source_lines_range (sal.line), 0);
1402 print_source_lines (sal.symtab,
1403 source_lines_range (sal.line, (sal_end.line + 1)),
1407 /* Subroutine of disassemble_command to simplify it.
1408 Perform the disassembly.
1409 NAME is the name of the function if known, or NULL.
1410 [LOW,HIGH) are the range of addresses to disassemble.
1411 BLOCK is the block to disassemble; it needs to be provided
1412 when non-contiguous blocks are disassembled; otherwise
1414 MIXED is non-zero to print source with the assembler. */
1417 print_disassembly (struct gdbarch *gdbarch, const char *name,
1418 CORE_ADDR low, CORE_ADDR high,
1419 const struct block *block,
1420 gdb_disassembly_flags flags)
1423 if (tui_is_window_visible (DISASSEM_WIN))
1424 tui_show_assembly (gdbarch, low);
1428 gdb_printf (_("Dump of assembler code "));
1430 gdb_printf (_("for function %ps:\n"),
1431 styled_string (function_name_style.style (), name));
1432 if (block == nullptr || BLOCK_CONTIGUOUS_P (block))
1435 gdb_printf (_("from %ps to %ps:\n"),
1436 styled_string (address_style.style (),
1437 paddress (gdbarch, low)),
1438 styled_string (address_style.style (),
1439 paddress (gdbarch, high)));
1441 /* Dump the specified range. */
1442 gdb_disassembly (gdbarch, current_uiout, flags, -1, low, high);
1446 for (int i = 0; i < BLOCK_NRANGES (block); i++)
1448 CORE_ADDR range_low = BLOCK_RANGE_START (block, i);
1449 CORE_ADDR range_high = BLOCK_RANGE_END (block, i);
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->dirname ();
2055 const char *dirb = salb.symtab->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);
2426 add_cmd ("status", class_info, _("Status inquiries."), &cmdlist);
2427 add_cmd ("files", class_files, _("Specifying and examining files."),
2429 add_cmd ("breakpoints", class_breakpoint,
2430 _("Making program stop at certain points."), &cmdlist);
2431 add_cmd ("data", class_vars, _("Examining data."), &cmdlist);
2432 add_cmd ("stack", class_stack, _("\
2433 Examining the stack.\n\
2434 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
2435 counting from zero for the innermost (currently executing) frame.\n\n\
2436 At any time gdb identifies one frame as the \"selected\" frame.\n\
2437 Variable lookups are done with respect to the selected frame.\n\
2438 When the program being debugged stops, gdb selects the innermost frame.\n\
2439 The commands below can be used to select other frames by number or address."),
2442 add_cmd ("text-user-interface", class_tui,
2443 _("TUI is the GDB text based interface.\n\
2444 In TUI mode, GDB can display several text windows showing\n\
2445 the source file, the processor registers, the program disassembly, ..."), &cmdlist);
2447 add_cmd ("running", class_run, _("Running the program."), &cmdlist);
2449 /* Define general commands. */
2451 add_com ("pwd", class_files, pwd_command, _("\
2452 Print working directory.\n\
2453 This is used for your program as well."));
2455 c = add_cmd ("cd", class_files, cd_command, _("\
2456 Set working directory to DIR for debugger.\n\
2457 The debugger's current working directory specifies where scripts and other\n\
2458 files that can be loaded by GDB are located.\n\
2459 In order to change the inferior's current working directory, the recommended\n\
2460 way is to use the \"set cwd\" command."), &cmdlist);
2461 set_cmd_completer (c, filename_completer);
2463 add_com ("echo", class_support, echo_command, _("\
2464 Print a constant string. Give string as argument.\n\
2465 C escape sequences may be used in the argument.\n\
2466 No newline is added at the end of the argument;\n\
2467 use \"\\n\" if you want a newline to be printed.\n\
2468 Since leading and trailing whitespace are ignored in command arguments,\n\
2469 if you want to print some you must use \"\\\" before leading whitespace\n\
2470 to be printed or after trailing whitespace."));
2472 add_setshow_enum_cmd ("script-extension", class_support,
2473 script_ext_enums, &script_ext_mode, _("\
2474 Set mode for script filename extension recognition."), _("\
2475 Show mode for script filename extension recognition."), _("\
2476 off == no filename extension recognition (all sourced files are GDB scripts)\n\
2477 soft == evaluate script according to filename extension, fallback to GDB script"
2479 strict == evaluate script according to filename extension, error if not supported"
2482 show_script_ext_mode,
2483 &setlist, &showlist);
2485 cmd_list_element *quit_cmd
2486 = add_com ("quit", class_support, quit_command, _("\
2488 Usage: quit [EXPR] or exit [EXPR]\n\
2489 The optional expression EXPR, if present, is evaluated and the result\n\
2490 used as GDB's exit code. The default is zero."));
2491 cmd_list_element *help_cmd
2492 = add_com ("help", class_support, help_command,
2493 _("Print list of commands."));
2494 set_cmd_completer (help_cmd, command_completer);
2495 add_com_alias ("q", quit_cmd, class_support, 1);
2496 add_com_alias ("exit", quit_cmd, class_support, 1);
2497 add_com_alias ("h", help_cmd, class_support, 1);
2499 add_setshow_boolean_cmd ("verbose", class_support, &info_verbose, _("\
2500 Set verbosity."), _("\
2501 Show verbosity."), NULL,
2504 &setlist, &showlist);
2506 add_setshow_prefix_cmd
2507 ("history", class_support,
2508 _("Generic command for setting command history parameters."),
2509 _("Generic command for showing command history parameters."),
2510 &sethistlist, &showhistlist, &setlist, &showlist);
2512 add_setshow_boolean_cmd ("expansion", no_class, &history_expansion_p, _("\
2513 Set history expansion on command input."), _("\
2514 Show history expansion on command input."), _("\
2515 Without an argument, history expansion is enabled."),
2517 show_history_expansion_p,
2518 &sethistlist, &showhistlist);
2520 cmd_list_element *info_cmd
2521 = add_prefix_cmd ("info", class_info, info_command, _("\
2522 Generic command for showing things about the program being debugged."),
2523 &infolist, 0, &cmdlist);
2524 add_com_alias ("i", info_cmd, class_info, 1);
2525 add_com_alias ("inf", info_cmd, class_info, 1);
2527 add_com ("complete", class_obscure, complete_command,
2528 _("List the completions for the rest of the line as a command."));
2530 c = add_show_prefix_cmd ("show", class_info, _("\
2531 Generic command for showing things about the debugger."),
2532 &showlist, 0, &cmdlist);
2533 /* Another way to get at the same thing. */
2534 add_alias_cmd ("set", c, class_info, 0, &infolist);
2536 cmd_list_element *with_cmd
2537 = add_com ("with", class_vars, with_command, _("\
2538 Temporarily set SETTING to VALUE, run COMMAND, and restore SETTING.\n\
2539 Usage: with SETTING [VALUE] [-- COMMAND]\n\
2540 Usage: w SETTING [VALUE] [-- COMMAND]\n\
2541 With no COMMAND, repeats the last executed command.\n\
2543 SETTING is any setting you can change with the \"set\" subcommands.\n\
2545 with language pascal -- print obj\n\
2546 with print elements unlimited -- print obj\n\
2548 You can change multiple settings using nested with, and use\n\
2549 abbreviations for commands and/or values. E.g.:\n\
2550 w la p -- w p el u -- p obj"));
2551 set_cmd_completer_handle_brkchars (with_cmd, with_command_completer);
2552 add_com_alias ("w", with_cmd, class_vars, 1);
2554 add_internal_function ("_gdb_setting_str", _("\
2555 $_gdb_setting_str - returns the value of a GDB setting as a string.\n\
2556 Usage: $_gdb_setting_str (setting)\n\
2558 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2559 boolean values are \"off\", \"on\".\n\
2560 Some integer settings accept an unlimited value, returned\n\
2561 as \"unlimited\"."),
2562 gdb_setting_str_internal_fn, NULL);
2564 add_internal_function ("_gdb_setting", _("\
2565 $_gdb_setting - returns the value of a GDB setting.\n\
2566 Usage: $_gdb_setting (setting)\n\
2567 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2568 boolean values are \"off\", \"on\".\n\
2569 Some integer settings accept an unlimited value, returned\n\
2570 as 0 or -1 depending on the setting."),
2571 gdb_setting_internal_fn, NULL);
2573 add_internal_function ("_gdb_maint_setting_str", _("\
2574 $_gdb_maint_setting_str - returns the value of a GDB maintenance setting as a string.\n\
2575 Usage: $_gdb_maint_setting_str (setting)\n\
2577 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2578 boolean values are \"off\", \"on\".\n\
2579 Some integer settings accept an unlimited value, returned\n\
2580 as \"unlimited\"."),
2581 gdb_maint_setting_str_internal_fn, NULL);
2583 add_internal_function ("_gdb_maint_setting", _("\
2584 $_gdb_maint_setting - returns the value of a GDB maintenance setting.\n\
2585 Usage: $_gdb_maint_setting (setting)\n\
2586 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2587 boolean values are \"off\", \"on\".\n\
2588 Some integer settings accept an unlimited value, returned\n\
2589 as 0 or -1 depending on the setting."),
2590 gdb_maint_setting_internal_fn, NULL);
2592 add_cmd ("commands", no_set_class, show_commands, _("\
2593 Show the history of commands you typed.\n\
2594 You can supply a command number to start with, or a `+' to start after\n\
2595 the previous command number shown."),
2598 add_cmd ("version", no_set_class, show_version,
2599 _("Show what version of GDB this is."), &showlist);
2601 add_cmd ("configuration", no_set_class, show_configuration,
2602 _("Show how GDB was configured at build time."), &showlist);
2604 add_setshow_prefix_cmd ("debug", no_class,
2605 _("Generic command for setting gdb debugging flags."),
2606 _("Generic command for showing gdb debugging flags."),
2607 &setdebuglist, &showdebuglist,
2608 &setlist, &showlist);
2610 cmd_list_element *shell_cmd
2611 = add_com ("shell", class_support, shell_command, _("\
2612 Execute the rest of the line as a shell command.\n\
2613 With no arguments, run an inferior shell."));
2614 set_cmd_completer (shell_cmd, filename_completer);
2616 add_com_alias ("!", shell_cmd, class_support, 0);
2618 c = add_com ("edit", class_files, edit_command, _("\
2619 Edit specified file or function.\n\
2620 With no argument, edits file containing most recent line listed.\n\
2621 Editing targets can be specified in these ways:\n\
2622 FILE:LINENUM, to edit at that line in that file,\n\
2623 FUNCTION, to edit at the beginning of that function,\n\
2624 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2625 *ADDRESS, to edit at the line containing that address.\n\
2626 Uses EDITOR environment variable contents as editor (or ex as default)."));
2628 c->completer = location_completer;
2630 cmd_list_element *pipe_cmd
2631 = add_com ("pipe", class_support, pipe_command, _("\
2632 Send the output of a gdb command to a shell command.\n\
2633 Usage: | [COMMAND] | SHELL_COMMAND\n\
2634 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2635 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
2636 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2638 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
2640 The -d option indicates to use the string DELIM to separate COMMAND\n\
2641 from SHELL_COMMAND, in alternative to |. This is useful in\n\
2642 case COMMAND contains a | character.\n\
2644 With no COMMAND, repeat the last executed command\n\
2645 and send its output to SHELL_COMMAND."));
2646 set_cmd_completer_handle_brkchars (pipe_cmd, pipe_command_completer);
2647 add_com_alias ("|", pipe_cmd, class_support, 0);
2649 cmd_list_element *list_cmd
2650 = add_com ("list", class_files, list_command, _("\
2651 List specified function or line.\n\
2652 With no argument, lists ten more lines after or around previous listing.\n\
2653 \"list -\" lists the ten lines before a previous ten-line listing.\n\
2654 One argument specifies a line, and ten lines are listed around that line.\n\
2655 Two arguments with comma between specify starting and ending lines to list.\n\
2656 Lines can be specified in these ways:\n\
2657 LINENUM, to list around that line in current file,\n\
2658 FILE:LINENUM, to list around that line in that file,\n\
2659 FUNCTION, to list around beginning of that function,\n\
2660 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2661 *ADDRESS, to list around the line containing that address.\n\
2662 With two args, if one is empty, it stands for ten lines away from\n\
2665 By default, when a single location is given, display ten lines.\n\
2666 This can be changed using \"set listsize\", and the current value\n\
2667 can be shown using \"show listsize\"."));
2669 add_com_alias ("l", list_cmd, class_files, 1);
2672 add_com_alias ("file", list_cmd, class_files, 1);
2674 c = add_com ("disassemble", class_vars, disassemble_command, _("\
2675 Disassemble a specified section of memory.\n\
2676 Usage: disassemble[/m|/r|/s] START [, END]\n\
2677 Default is the function surrounding the pc of the selected frame.\n\
2679 With a /s modifier, source lines are included (if available).\n\
2680 In this mode, the output is displayed in PC address order, and\n\
2681 file names and contents for all relevant source files are displayed.\n\
2683 With a /m modifier, source lines are included (if available).\n\
2684 This view is \"source centric\": the output is in source line order,\n\
2685 regardless of any optimization that is present. Only the main source file\n\
2686 is displayed, not those of, e.g., any inlined functions.\n\
2687 This modifier hasn't proved useful in practice and is deprecated\n\
2690 With a /r modifier, raw instructions in hex are included.\n\
2692 With a single argument, the function surrounding that address is dumped.\n\
2693 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
2694 in the form of \"start,end\", or \"start,+length\".\n\
2696 Note that the address is interpreted as an expression, not as a location\n\
2697 like in the \"break\" command.\n\
2698 So, for example, if you want to disassemble function bar in file foo.c\n\
2699 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
2700 set_cmd_completer (c, location_completer);
2702 c = add_com ("make", class_support, make_command, _("\
2703 Run the ``make'' program using the rest of the line as arguments."));
2704 set_cmd_completer (c, filename_completer);
2705 c = add_cmd ("user", no_class, show_user, _("\
2706 Show definitions of non-python/scheme user defined commands.\n\
2707 Argument is the name of the user defined command.\n\
2708 With no argument, show definitions of all user defined commands."), &showlist);
2709 set_cmd_completer (c, show_user_completer);
2710 add_com ("apropos", class_support, apropos_command, _("\
2711 Search for commands matching a REGEXP.\n\
2712 Usage: apropos [-v] REGEXP\n\
2713 Flag -v indicates to produce a verbose output, showing full documentation\n\
2714 of the matching commands."));
2716 add_setshow_uinteger_cmd ("max-user-call-depth", no_class,
2717 &max_user_call_depth, _("\
2718 Set the max call depth for non-python/scheme user-defined commands."), _("\
2719 Show the max call depth for non-python/scheme user-defined commands."), NULL,
2721 show_max_user_call_depth,
2722 &setlist, &showlist);
2724 add_setshow_boolean_cmd ("trace-commands", no_class, &trace_commands, _("\
2725 Set tracing of GDB CLI commands."), _("\
2726 Show state of GDB CLI command tracing."), _("\
2727 When 'on', each command is displayed as it is executed."),
2730 &setlist, &showlist);
2732 const auto alias_opts = make_alias_options_def_group (nullptr);
2734 static std::string alias_help
2735 = gdb::option::build_help (_("\
2736 Define a new command that is an alias of an existing command.\n\
2737 Usage: alias [-a] [--] ALIAS = COMMAND [DEFAULT-ARGS...]\n\
2738 ALIAS is the name of the alias command to create.\n\
2739 COMMAND is the command being aliased to.\n\
2744 GDB will automatically prepend the provided DEFAULT-ARGS to the list\n\
2745 of arguments explicitly provided when using ALIAS.\n\
2746 Use \"help aliases\" to list all user defined aliases and their default args.\n\
2749 Make \"spe\" an alias of \"set print elements\":\n\
2750 alias spe = set print elements\n\
2751 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2752 alias -a set print elms = set print elements\n\
2753 Make \"btf\" an alias of \"backtrace -full -past-entry -past-main\" :\n\
2754 alias btf = backtrace -full -past-entry -past-main\n\
2755 Make \"wLapPeu\" an alias of 2 nested \"with\":\n\
2756 alias wLapPeu = with language pascal -- with print elements unlimited --"),
2759 c = add_com ("alias", class_support, alias_command,
2760 alias_help.c_str ());
2762 set_cmd_completer_handle_brkchars (c, alias_command_completer);
2764 add_setshow_boolean_cmd ("suppress-cli-notifications", no_class,
2765 &user_wants_cli_suppress_notification,
2767 Set whether printing notifications on CLI is suppressed."), _("\
2768 Show whether printing notifications on CLI is suppressed."), _("\
2769 When on, printing notifications (such as inferior/thread switch)\n\
2770 on CLI is suppressed."),
2771 set_suppress_cli_notifications,
2772 show_suppress_cli_notifications,
2776 const char *source_help_text = xstrprintf (_("\
2777 Read commands from a file named FILE.\n\
2779 Usage: source [-s] [-v] FILE\n\
2780 -s: search for the script in the source search path,\n\
2781 even if FILE contains directories.\n\
2782 -v: each command in FILE is echoed as it is executed.\n\
2784 Note that the file \"%s\" is read automatically in this way\n\
2785 when GDB is started."), GDBINIT).release ();
2786 c = add_cmd ("source", class_support, source_command,
2787 source_help_text, &cmdlist);
2788 set_cmd_completer (c, filename_completer);