3 Copyright (C) 2000-2017 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/readline.h"
23 #include "readline/tilde.h"
24 #include "completer.h"
25 #include "target.h" /* For baud_rate, remote_debug and remote_timeout. */
26 #include "gdb_wait.h" /* For shell escape implementation. */
27 #include "gdb_regex.h" /* Used by apropos_command. */
28 #include "gdb_vfork.h"
30 #include "expression.h"
34 #include "filenames.h" /* For DOSish file names. */
38 #include "tracepoint.h"
39 #include "filestuff.h"
45 #include "cli/cli-decode.h"
46 #include "cli/cli-script.h"
47 #include "cli/cli-setshow.h"
48 #include "cli/cli-cmds.h"
49 #include "cli/cli-utils.h"
51 #include "extension.h"
54 #include "tui/tui.h" /* For tui_active et.al. */
61 /* Prototypes for local utility functions */
63 static void print_sal_location (const symtab_and_line
&sal
);
65 static void ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
66 const char *format
, ...)
67 ATTRIBUTE_PRINTF (2, 3);
69 static void filter_sals (std::vector
<symtab_and_line
> &);
72 /* Limit the call depth of user-defined commands */
73 unsigned int max_user_call_depth
;
75 /* Define all cmd_list_elements. */
77 /* Chain containing all defined commands. */
79 struct cmd_list_element
*cmdlist
;
81 /* Chain containing all defined info subcommands. */
83 struct cmd_list_element
*infolist
;
85 /* Chain containing all defined enable subcommands. */
87 struct cmd_list_element
*enablelist
;
89 /* Chain containing all defined disable subcommands. */
91 struct cmd_list_element
*disablelist
;
93 /* Chain containing all defined stop subcommands. */
95 struct cmd_list_element
*stoplist
;
97 /* Chain containing all defined delete subcommands. */
99 struct cmd_list_element
*deletelist
;
101 /* Chain containing all defined detach subcommands. */
103 struct cmd_list_element
*detachlist
;
105 /* Chain containing all defined kill subcommands. */
107 struct cmd_list_element
*killlist
;
109 /* Chain containing all defined set subcommands */
111 struct cmd_list_element
*setlist
;
113 /* Chain containing all defined unset subcommands */
115 struct cmd_list_element
*unsetlist
;
117 /* Chain containing all defined show subcommands. */
119 struct cmd_list_element
*showlist
;
121 /* Chain containing all defined \"set history\". */
123 struct cmd_list_element
*sethistlist
;
125 /* Chain containing all defined \"show history\". */
127 struct cmd_list_element
*showhistlist
;
129 /* Chain containing all defined \"unset history\". */
131 struct cmd_list_element
*unsethistlist
;
133 /* Chain containing all defined maintenance subcommands. */
135 struct cmd_list_element
*maintenancelist
;
137 /* Chain containing all defined "maintenance info" subcommands. */
139 struct cmd_list_element
*maintenanceinfolist
;
141 /* Chain containing all defined "maintenance print" subcommands. */
143 struct cmd_list_element
*maintenanceprintlist
;
145 /* Chain containing all defined "maintenance check" subcommands. */
147 struct cmd_list_element
*maintenancechecklist
;
149 struct cmd_list_element
*setprintlist
;
151 struct cmd_list_element
*showprintlist
;
153 struct cmd_list_element
*setdebuglist
;
155 struct cmd_list_element
*showdebuglist
;
157 struct cmd_list_element
*setchecklist
;
159 struct cmd_list_element
*showchecklist
;
161 /* Command tracing state. */
163 int source_verbose
= 0;
164 int trace_commands
= 0;
166 /* 'script-extension' option support. */
168 static const char script_ext_off
[] = "off";
169 static const char script_ext_soft
[] = "soft";
170 static const char script_ext_strict
[] = "strict";
172 static const char *const script_ext_enums
[] = {
179 static const char *script_ext_mode
= script_ext_soft
;
181 /* Utility used everywhere when at least one argument is needed and
185 error_no_arg (const char *why
)
187 error (_("Argument required (%s)."), why
);
190 /* The "info" command is defined as a prefix, with allow_unknown = 0.
191 Therefore, its own definition is called only for "info" with no
195 info_command (const char *arg
, int from_tty
)
197 printf_unfiltered (_("\"info\" must be followed by "
198 "the name of an info command.\n"));
199 help_list (infolist
, "info ", all_commands
, gdb_stdout
);
202 /* The "show" command with no arguments shows all the settings. */
205 show_command (const char *arg
, int from_tty
)
207 cmd_show_list (showlist
, from_tty
, "");
210 /* A temporary non-const overload of show_command. */
213 show_command (char *arg
, int from_tty
)
215 cmd_show_list (showlist
, from_tty
, "");
219 /* Provide documentation on command or list given by COMMAND. FROM_TTY
223 help_command (const char *command
, int from_tty
)
225 help_cmd (command
, gdb_stdout
);
229 /* Note: The "complete" command is used by Emacs to implement completion.
230 [Is that why this function writes output with *_unfiltered?] */
233 complete_command (const char *arg
, int from_tty
)
237 if (max_completions
== 0)
239 /* Only print this for non-mi frontends. An MI frontend may not
240 be able to handle this. */
241 if (!current_uiout
->is_mi_like_p ())
243 printf_unfiltered (_("max-completions is zero,"
244 " completion is disabled.\n"));
252 completion_tracker tracker_handle_brkchars
;
253 completion_tracker tracker_handle_completions
;
254 completion_tracker
*tracker
;
256 int quote_char
= '\0';
261 word
= completion_find_completion_word (tracker_handle_brkchars
,
264 /* Completers that provide a custom word point in the
265 handle_brkchars phase also compute their completions then.
266 Completers that leave the completion word handling to readline
267 must be called twice. */
268 if (tracker_handle_brkchars
.use_custom_word_point ())
269 tracker
= &tracker_handle_brkchars
;
272 complete_line (tracker_handle_completions
, word
, arg
, strlen (arg
));
273 tracker
= &tracker_handle_completions
;
276 CATCH (ex
, RETURN_MASK_ALL
)
282 std::string
arg_prefix (arg
, word
- arg
);
284 completion_result result
285 = tracker
->build_completion_result (word
, word
- arg
, strlen (arg
));
287 if (result
.number_matches
!= 0)
289 if (result
.number_matches
== 1)
290 printf_unfiltered ("%s%s\n", arg_prefix
.c_str (), result
.match_list
[0]);
293 result
.sort_match_list ();
295 for (size_t i
= 0; i
< result
.number_matches
; i
++)
297 printf_unfiltered ("%s%s",
299 result
.match_list
[i
+ 1]);
301 printf_unfiltered ("%c", quote_char
);
302 printf_unfiltered ("\n");
306 if (result
.number_matches
== max_completions
)
308 /* ARG_PREFIX and WORD are included in the output so that emacs
309 will include the message in the output. */
310 printf_unfiltered (_("%s%s %s\n"),
311 arg_prefix
.c_str (), word
,
312 get_max_completions_reached_message ());
318 is_complete_command (struct cmd_list_element
*c
)
320 return cmd_cfunc_eq (c
, complete_command
);
324 show_version (const char *args
, int from_tty
)
326 print_gdb_version (gdb_stdout
);
327 printf_filtered ("\n");
331 show_configuration (const char *args
, int from_tty
)
333 print_gdb_configuration (gdb_stdout
);
336 /* Handle the quit command. */
339 quit_command (const char *args
, int from_tty
)
343 /* An optional expression may be used to cause gdb to terminate with
344 the value of that expression. */
347 struct value
*val
= parse_and_eval (args
);
349 exit_code
= (int) value_as_long (val
);
352 if (!quit_confirm ())
353 error (_("Not confirmed."));
355 query_if_trace_running (from_tty
);
357 quit_force (args
? &exit_code
: NULL
, from_tty
);
361 pwd_command (const char *args
, int from_tty
)
364 error (_("The \"pwd\" command does not take an argument: %s"), args
);
366 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
369 error (_("Error finding name of working directory: %s"),
370 safe_strerror (errno
));
372 if (strcmp (cwd
.get (), current_directory
) != 0)
373 printf_unfiltered (_("Working directory %s\n (canonically %s).\n"),
374 current_directory
, cwd
.get ());
376 printf_unfiltered (_("Working directory %s.\n"), current_directory
);
380 cd_command (const char *dir
, int from_tty
)
383 /* Found something other than leading repetitions of "/..". */
387 /* If the new directory is absolute, repeat is a no-op; if relative,
388 repeat might be useful but is more likely to be a mistake. */
391 gdb::unique_xmalloc_ptr
<char> dir_holder
392 (tilde_expand (dir
!= NULL
? dir
: "~"));
393 dir
= dir_holder
.get ();
396 perror_with_name (dir
);
398 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
399 /* There's too much mess with DOSish names like "d:", "d:.",
400 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
401 simply get the canonicalized name of the current directory. */
402 gdb::unique_xmalloc_ptr
<char> cwd (getcwd (NULL
, 0));
407 if (IS_DIR_SEPARATOR (dir
[len
- 1]))
409 /* Remove the trailing slash unless this is a root directory
410 (including a drive letter on non-Unix systems). */
411 if (!(len
== 1) /* "/" */
412 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
413 && !(len
== 3 && dir
[1] == ':') /* "d:/" */
419 dir_holder
.reset (savestring (dir
, len
));
420 if (IS_ABSOLUTE_PATH (dir_holder
.get ()))
422 xfree (current_directory
);
423 current_directory
= dir_holder
.release ();
427 if (IS_DIR_SEPARATOR (current_directory
[strlen (current_directory
) - 1]))
428 current_directory
= concat (current_directory
, dir_holder
.get (),
431 current_directory
= concat (current_directory
, SLASH_STRING
,
432 dir_holder
.get (), (char *) NULL
);
435 /* Now simplify any occurrences of `.' and `..' in the pathname. */
438 for (p
= current_directory
; *p
;)
440 if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.'
441 && (p
[2] == 0 || IS_DIR_SEPARATOR (p
[2])))
442 memmove (p
, p
+ 2, strlen (p
+ 2) + 1);
443 else if (IS_DIR_SEPARATOR (p
[0]) && p
[1] == '.' && p
[2] == '.'
444 && (p
[3] == 0 || IS_DIR_SEPARATOR (p
[3])))
448 /* Search backwards for the directory just before the "/.."
449 and obliterate it and the "/..". */
452 while (q
!= current_directory
&& !IS_DIR_SEPARATOR (q
[-1]))
455 if (q
== current_directory
)
456 /* current_directory is
457 a relative pathname ("can't happen"--leave it alone). */
461 memmove (q
- 1, p
+ 3, strlen (p
+ 3) + 1);
466 /* We are dealing with leading repetitions of "/..", for
467 example "/../..", which is the Mach super-root. */
477 forget_cached_source_info ();
480 pwd_command ((char *) 0, 1);
483 /* Show the current value of the 'script-extension' option. */
486 show_script_ext_mode (struct ui_file
*file
, int from_tty
,
487 struct cmd_list_element
*c
, const char *value
)
489 fprintf_filtered (file
,
490 _("Script filename extension recognition is \"%s\".\n"),
494 /* Try to open SCRIPT_FILE.
495 If successful, the full path name is stored in *FULL_PATHP,
496 and the stream is returned.
497 If not successful, return NULL; errno is set for the last file
500 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
501 search for it in the source search path. */
503 gdb::optional
<open_script
>
504 find_and_open_script (const char *script_file
, int search_path
)
507 int search_flags
= OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
;
508 gdb::optional
<open_script
> opened
;
510 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (script_file
));
513 search_flags
|= OPF_SEARCH_IN_PATH
;
515 /* Search for and open 'file' on the search path used for source
516 files. Put the full location in *FULL_PATHP. */
518 fd
= openp (source_path
, search_flags
,
519 file
.get (), O_RDONLY
, &temp_path
);
520 gdb::unique_xmalloc_ptr
<char> full_path (temp_path
);
525 FILE *result
= fdopen (fd
, FOPEN_RT
);
528 int save_errno
= errno
;
534 opened
.emplace (gdb_file_up (result
), std::move (full_path
));
539 /* Load script FILE, which has already been opened as STREAM.
540 FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
541 This is provided as FILE may have been found via the source search path.
542 An important thing to note here is that FILE may be a symlink to a file
543 with a different or non-existing suffix, and thus one cannot infer the
544 extension language from FILE_TO_OPEN. */
547 source_script_from_stream (FILE *stream
, const char *file
,
548 const char *file_to_open
)
550 if (script_ext_mode
!= script_ext_off
)
552 const struct extension_language_defn
*extlang
553 = get_ext_lang_of_file (file
);
557 if (ext_lang_present_p (extlang
))
559 script_sourcer_func
*sourcer
560 = ext_lang_script_sourcer (extlang
);
562 gdb_assert (sourcer
!= NULL
);
563 sourcer (extlang
, stream
, file_to_open
);
566 else if (script_ext_mode
== script_ext_soft
)
568 /* Assume the file is a gdb script.
569 This is handled below. */
572 throw_ext_lang_unsupported (extlang
);
576 script_from_file (stream
, file
);
579 /* Worker to perform the "source" command.
581 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
582 search for it in the source search path. */
585 source_script_with_search (const char *file
, int from_tty
, int search_path
)
588 if (file
== NULL
|| *file
== 0)
589 error (_("source command requires file name of file to source."));
591 gdb::optional
<open_script
> opened
= find_and_open_script (file
, search_path
);
594 /* The script wasn't found, or was otherwise inaccessible.
595 If the source command was invoked interactively, throw an
596 error. Otherwise (e.g. if it was invoked by a script),
597 just emit a warning, rather than cause an error. */
599 perror_with_name (file
);
602 perror_warning_with_name (file
);
607 /* The python support reopens the file, so we need to pass full_path here
608 in case the file was found on the search path. It's useful to do this
609 anyway so that error messages show the actual file used. But only do
610 this if we (may have) used search_path, as printing the full path in
611 errors for the non-search case can be more noise than signal. */
612 source_script_from_stream (opened
->stream
.get (), file
,
613 search_path
? opened
->full_path
.get () : file
);
616 /* Wrapper around source_script_with_search to export it to main.c
617 for use in loading .gdbinit scripts. */
620 source_script (const char *file
, int from_tty
)
622 source_script_with_search (file
, from_tty
, 0);
626 source_command (const char *args
, int from_tty
)
628 const char *file
= args
;
631 scoped_restore save_source_verbose
= make_scoped_restore (&source_verbose
);
633 /* -v causes the source command to run in verbose mode.
634 -s causes the file to be searched in the source search path,
635 even if the file name contains a '/'.
636 We still have to be able to handle filenames with spaces in a
637 backward compatible way, so buildargv is not appropriate. */
641 while (args
[0] != '\0')
643 /* Make sure leading white space does not break the
645 args
= skip_spaces (args
);
650 if (args
[1] == 'v' && isspace (args
[2]))
654 /* Skip passed -v. */
657 else if (args
[1] == 's' && isspace (args
[2]))
661 /* Skip passed -s. */
668 file
= skip_spaces (args
);
671 source_script_with_search (file
, from_tty
, search_path
);
676 echo_command (const char *text
, int from_tty
)
678 const char *p
= text
;
682 while ((c
= *p
++) != '\0')
686 /* \ at end of argument is used after spaces
687 so they won't be lost. */
691 c
= parse_escape (get_current_arch (), &p
);
693 printf_filtered ("%c", c
);
696 printf_filtered ("%c", c
);
699 /* Force this output to appear now. */
701 gdb_flush (gdb_stdout
);
705 shell_escape (const char *arg
, int from_tty
)
707 #if defined(CANT_FORK) || \
708 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
709 /* If ARG is NULL, they want an inferior shell, but `system' just
710 reports if the shell is available when passed a NULL arg. */
711 int rc
= system (arg
? arg
: "");
714 arg
= "inferior shell";
718 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", arg
,
719 safe_strerror (errno
));
720 gdb_flush (gdb_stderr
);
724 fprintf_unfiltered (gdb_stderr
, "%s exited with status %d\n", arg
, rc
);
725 gdb_flush (gdb_stderr
);
728 /* Make sure to return to the directory GDB thinks it is, in case
729 the shell command we just ran changed it. */
730 chdir (current_directory
);
732 #else /* Can fork. */
735 if ((pid
= vfork ()) == 0)
737 const char *p
, *user_shell
;
741 if ((user_shell
= (char *) getenv ("SHELL")) == NULL
)
742 user_shell
= "/bin/sh";
744 /* Get the name of the shell for arg0. */
745 p
= lbasename (user_shell
);
748 execl (user_shell
, p
, (char *) 0);
750 execl (user_shell
, p
, "-c", arg
, (char *) 0);
752 fprintf_unfiltered (gdb_stderr
, "Cannot execute %s: %s\n", user_shell
,
753 safe_strerror (errno
));
754 gdb_flush (gdb_stderr
);
759 waitpid (pid
, &status
, 0);
761 error (_("Fork failed"));
762 #endif /* Can fork. */
765 /* Implementation of the "shell" command. */
768 shell_command (const char *arg
, int from_tty
)
770 shell_escape (arg
, from_tty
);
774 edit_command (const char *arg
, int from_tty
)
776 struct symtab_and_line sal
;
782 /* Pull in the current default source line if necessary. */
785 set_default_source_symtab_and_line ();
786 sal
= get_current_source_symtab_and_line ();
789 /* Bare "edit" edits file with present line. */
794 error (_("No default source file yet."));
795 sal
.line
+= get_lines_to_list () / 2;
801 /* Now should only be one argument -- decode it in SAL. */
803 event_location_up location
= string_to_event_location (&arg1
,
805 std::vector
<symtab_and_line
> sals
= decode_line_1 (location
.get (),
806 DECODE_LINE_LIST_MODE
,
815 if (sals
.size () > 1)
817 ambiguous_line_spec (sals
,
818 _("Specified line is ambiguous:\n"));
825 error (_("Junk at end of line specification."));
827 /* If line was specified by address, first print exactly which
828 line, and which file. In this case, sal.symtab == 0 means
829 address is outside of all known source files, not that user
830 failed to give a filename. */
833 struct gdbarch
*gdbarch
;
836 error (_("No source file for address %s."),
837 paddress (get_current_arch (), sal
.pc
));
839 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
840 sym
= find_pc_function (sal
.pc
);
842 printf_filtered ("%s is in %s (%s:%d).\n",
843 paddress (gdbarch
, sal
.pc
),
844 SYMBOL_PRINT_NAME (sym
),
845 symtab_to_filename_for_display (sal
.symtab
),
848 printf_filtered ("%s is at %s:%d.\n",
849 paddress (gdbarch
, sal
.pc
),
850 symtab_to_filename_for_display (sal
.symtab
),
854 /* If what was given does not imply a symtab, it must be an
855 undebuggable symbol which means no source code. */
858 error (_("No line number known for %s."), arg
);
861 if ((editor
= (char *) getenv ("EDITOR")) == NULL
)
864 fn
= symtab_to_fullname (sal
.symtab
);
866 /* Quote the file name, in case it has whitespace or other special
868 p
= xstrprintf ("%s +%d \"%s\"", editor
, sal
.line
, fn
);
869 shell_escape (p
, from_tty
);
874 list_command (const char *arg
, int from_tty
)
884 /* Pull in the current default source line if necessary. */
885 if (arg
== NULL
|| ((arg
[0] == '+' || arg
[0] == '-') && arg
[1] == '\0'))
887 set_default_source_symtab_and_line ();
888 symtab_and_line cursal
= get_current_source_symtab_and_line ();
890 /* If this is the first "list" since we've set the current
891 source line, center the listing around that line. */
892 if (get_first_line_listed () == 0)
896 first
= std::max (cursal
.line
- get_lines_to_list () / 2, 1);
898 /* A small special case --- if listing backwards, and we
899 should list only one line, list the preceding line,
900 instead of the exact line we've just shown after e.g.,
901 stopping for a breakpoint. */
902 if (arg
!= NULL
&& arg
[0] == '-'
903 && get_lines_to_list () == 1 && first
> 1)
906 print_source_lines (cursal
.symtab
, first
,
907 first
+ get_lines_to_list (), 0);
910 /* "l" or "l +" lists next ten lines. */
911 else if (arg
== NULL
|| arg
[0] == '+')
912 print_source_lines (cursal
.symtab
, cursal
.line
,
913 cursal
.line
+ get_lines_to_list (), 0);
915 /* "l -" lists previous ten lines, the ones before the ten just
917 else if (arg
[0] == '-')
919 if (get_first_line_listed () == 1)
920 error (_("Already at the start of %s."),
921 symtab_to_filename_for_display (cursal
.symtab
));
922 print_source_lines (cursal
.symtab
,
923 std::max (get_first_line_listed ()
924 - get_lines_to_list (), 1),
925 get_first_line_listed (), 0);
931 /* Now if there is only one argument, decode it in SAL
933 If there are two arguments, decode them in SAL and SAL_END
934 and clear NO_END; however, if one of the arguments is blank,
935 set DUMMY_BEG or DUMMY_END to record that fact. */
937 if (!have_full_symbols () && !have_partial_symbols ())
938 error (_("No symbol table is loaded. Use the \"file\" command."));
940 std::vector
<symtab_and_line
> sals
;
941 symtab_and_line sal
, sal_end
;
948 event_location_up location
= string_to_event_location (&arg1
,
950 sals
= decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
962 /* Record whether the BEG arg is all digits. */
964 for (p
= arg
; p
!= arg1
&& *p
>= '0' && *p
<= '9'; p
++);
965 linenum_beg
= (p
== arg1
);
967 /* Save the range of the first argument, in case we need to let the
968 user know it was ambiguous. */
969 const char *beg
= arg
;
970 size_t beg_len
= arg1
- beg
;
972 while (*arg1
== ' ' || *arg1
== '\t')
977 if (sals
.size () > 1)
979 ambiguous_line_spec (sals
,
980 _("Specified first line '%.*s' is ambiguous:\n"),
985 while (*arg1
== ' ' || *arg1
== '\t')
991 /* Save the last argument, in case we need to let the user
992 know it was ambiguous. */
993 const char *end_arg
= arg1
;
995 event_location_up location
996 = string_to_event_location (&arg1
, current_language
);
998 std::vector
<symtab_and_line
> sals_end
1000 ? decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1002 : decode_line_1 (location
.get (), DECODE_LINE_LIST_MODE
,
1003 NULL
, sal
.symtab
, sal
.line
));
1005 filter_sals (sals_end
);
1006 if (sals_end
.empty ())
1008 if (sals_end
.size () > 1)
1010 ambiguous_line_spec (sals_end
,
1011 _("Specified last line '%s' is ambiguous:\n"),
1015 sal_end
= sals_end
[0];
1020 error (_("Junk at end of line specification."));
1022 if (!no_end
&& !dummy_beg
&& !dummy_end
1023 && sal
.symtab
!= sal_end
.symtab
)
1024 error (_("Specified first and last lines are in different files."));
1025 if (dummy_beg
&& dummy_end
)
1026 error (_("Two empty args do not say what lines to list."));
1028 /* If line was specified by address,
1029 first print exactly which line, and which file.
1031 In this case, sal.symtab == 0 means address is outside of all
1032 known source files, not that user failed to give a filename. */
1035 struct gdbarch
*gdbarch
;
1037 if (sal
.symtab
== 0)
1038 error (_("No source file for address %s."),
1039 paddress (get_current_arch (), sal
.pc
));
1041 gdbarch
= get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
1042 sym
= find_pc_function (sal
.pc
);
1044 printf_filtered ("%s is in %s (%s:%d).\n",
1045 paddress (gdbarch
, sal
.pc
),
1046 SYMBOL_PRINT_NAME (sym
),
1047 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1049 printf_filtered ("%s is at %s:%d.\n",
1050 paddress (gdbarch
, sal
.pc
),
1051 symtab_to_filename_for_display (sal
.symtab
), sal
.line
);
1054 /* If line was not specified by just a line number, and it does not
1055 imply a symtab, it must be an undebuggable symbol which means no
1058 if (!linenum_beg
&& sal
.symtab
== 0)
1059 error (_("No line number known for %s."), arg
);
1061 /* If this command is repeated with RET,
1062 turn it into the no-arg variant. */
1065 set_repeat_arguments ("");
1067 if (dummy_beg
&& sal_end
.symtab
== 0)
1068 error (_("No default source file yet. Do \"help list\"."));
1070 print_source_lines (sal_end
.symtab
,
1071 std::max (sal_end
.line
- (get_lines_to_list () - 1), 1),
1072 sal_end
.line
+ 1, 0);
1073 else if (sal
.symtab
== 0)
1074 error (_("No default source file yet. Do \"help list\"."));
1077 for (int i
= 0; i
< sals
.size (); i
++)
1080 int first_line
= sal
.line
- get_lines_to_list () / 2;
1083 if (sals
.size () > 1)
1084 print_sal_location (sal
);
1085 print_source_lines (sal
.symtab
,
1087 first_line
+ get_lines_to_list (),
1092 print_source_lines (sal
.symtab
, sal
.line
,
1094 ? sal
.line
+ get_lines_to_list ()
1095 : sal_end
.line
+ 1),
1099 /* Subroutine of disassemble_command to simplify it.
1100 Perform the disassembly.
1101 NAME is the name of the function if known, or NULL.
1102 [LOW,HIGH) are the range of addresses to disassemble.
1103 MIXED is non-zero to print source with the assembler. */
1106 print_disassembly (struct gdbarch
*gdbarch
, const char *name
,
1107 CORE_ADDR low
, CORE_ADDR high
,
1108 gdb_disassembly_flags flags
)
1111 if (!tui_is_window_visible (DISASSEM_WIN
))
1114 printf_filtered ("Dump of assembler code ");
1116 printf_filtered ("for function %s:\n", name
);
1118 printf_filtered ("from %s to %s:\n",
1119 paddress (gdbarch
, low
), paddress (gdbarch
, high
));
1121 /* Dump the specified range. */
1122 gdb_disassembly (gdbarch
, current_uiout
, flags
, -1, low
, high
);
1124 printf_filtered ("End of assembler dump.\n");
1125 gdb_flush (gdb_stdout
);
1130 tui_show_assembly (gdbarch
, low
);
1135 /* Subroutine of disassemble_command to simplify it.
1136 Print a disassembly of the current function according to FLAGS. */
1139 disassemble_current_function (gdb_disassembly_flags flags
)
1141 struct frame_info
*frame
;
1142 struct gdbarch
*gdbarch
;
1143 CORE_ADDR low
, high
, pc
;
1146 frame
= get_selected_frame (_("No frame selected."));
1147 gdbarch
= get_frame_arch (frame
);
1148 pc
= get_frame_address_in_block (frame
);
1149 if (find_pc_partial_function (pc
, &name
, &low
, &high
) == 0)
1150 error (_("No function contains program counter for selected frame."));
1152 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1155 /* FIXME: cagney/2004-02-07: This should be an observer. */
1156 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1158 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1160 print_disassembly (gdbarch
, name
, low
, high
, flags
);
1163 /* Dump a specified section of assembly code.
1167 - dump the assembly code for the function of the current pc
1168 disassemble [/mrs] addr
1169 - dump the assembly code for the function at ADDR
1170 disassemble [/mrs] low,high
1171 disassemble [/mrs] low,+length
1172 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1174 A /m modifier will include source code with the assembly in a
1175 "source centric" view. This view lists only the file of the first insn,
1176 even if other source files are involved (e.g., inlined functions), and
1177 the output is in source order, even with optimized code. This view is
1178 considered deprecated as it hasn't been useful in practice.
1180 A /r modifier will include raw instructions in hex with the assembly.
1182 A /s modifier will include source code with the assembly, like /m, with
1183 two important differences:
1184 1) The output is still in pc address order.
1185 2) File names and contents for all relevant source files are displayed. */
1188 disassemble_command (const char *arg
, int from_tty
)
1190 struct gdbarch
*gdbarch
= get_current_arch ();
1191 CORE_ADDR low
, high
;
1194 gdb_disassembly_flags flags
;
1206 error (_("Missing modifier."));
1208 while (*p
&& ! isspace (*p
))
1213 flags
|= DISASSEMBLY_SOURCE_DEPRECATED
;
1216 flags
|= DISASSEMBLY_RAW_INSN
;
1219 flags
|= DISASSEMBLY_SOURCE
;
1222 error (_("Invalid disassembly modifier."));
1226 p
= skip_spaces (p
);
1229 if ((flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1230 == (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1231 error (_("Cannot specify both /m and /s."));
1235 flags
|= DISASSEMBLY_OMIT_FNAME
;
1236 disassemble_current_function (flags
);
1240 pc
= value_as_address (parse_to_comma_and_eval (&p
));
1246 if (find_pc_partial_function (pc
, &name
, &low
, &high
) == 0)
1247 error (_("No function contains specified address."));
1249 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1252 /* FIXME: cagney/2004-02-07: This should be an observer. */
1253 low
= tui_get_low_disassembly_address (gdbarch
, low
, pc
);
1255 low
+= gdbarch_deprecated_function_start_offset (gdbarch
);
1256 flags
|= DISASSEMBLY_OMIT_FNAME
;
1260 /* Two arguments. */
1263 p
= skip_spaces (p
);
1269 high
= parse_and_eval_address (p
);
1274 print_disassembly (gdbarch
, name
, low
, high
, flags
);
1278 make_command (const char *arg
, int from_tty
)
1281 shell_escape ("make", from_tty
);
1284 std::string cmd
= std::string ("make ") + arg
;
1286 shell_escape (cmd
.c_str (), from_tty
);
1291 show_user (const char *args
, int from_tty
)
1293 struct cmd_list_element
*c
;
1294 extern struct cmd_list_element
*cmdlist
;
1298 const char *comname
= args
;
1300 c
= lookup_cmd (&comname
, cmdlist
, "", 0, 1);
1301 if (!cli_user_command_p (c
))
1302 error (_("Not a user command."));
1303 show_user_1 (c
, "", args
, gdb_stdout
);
1307 for (c
= cmdlist
; c
; c
= c
->next
)
1309 if (cli_user_command_p (c
) || c
->prefixlist
!= NULL
)
1310 show_user_1 (c
, "", c
->name
, gdb_stdout
);
1315 /* Search through names of commands and documentations for a certain
1316 regular expression. */
1319 apropos_command (const char *searchstr
, int from_tty
)
1321 if (searchstr
== NULL
)
1322 error (_("REGEXP string is empty"));
1324 compiled_regex
pattern (searchstr
, REG_ICASE
,
1325 _("Error in regular expression"));
1327 apropos_cmd (gdb_stdout
, cmdlist
, pattern
, "");
1330 /* Subroutine of alias_command to simplify it.
1331 Return the first N elements of ARGV flattened back to a string
1332 with a space separating each element.
1333 ARGV may not be NULL.
1334 This does not take care of quoting elements in case they contain spaces
1338 argv_to_string (char **argv
, int n
)
1343 gdb_assert (argv
!= NULL
);
1344 gdb_assert (n
>= 0 && n
<= countargv (argv
));
1346 for (i
= 0; i
< n
; ++i
)
1356 /* Subroutine of alias_command to simplify it.
1357 Return TRUE if COMMAND exists, unambiguously. Otherwise FALSE. */
1360 valid_command_p (const char *command
)
1362 struct cmd_list_element
*c
;
1364 c
= lookup_cmd_1 (& command
, cmdlist
, NULL
, 1);
1366 if (c
== NULL
|| c
== (struct cmd_list_element
*) -1)
1369 /* This is the slightly tricky part.
1370 lookup_cmd_1 will return a pointer to the last part of COMMAND
1371 to match, leaving COMMAND pointing at the remainder. */
1372 while (*command
== ' ' || *command
== '\t')
1374 return *command
== '\0';
1377 /* Called when "alias" was incorrectly used. */
1380 alias_usage_error (void)
1382 error (_("Usage: alias [-a] [--] ALIAS = COMMAND"));
1385 /* Make an alias of an existing command. */
1388 alias_command (const char *args
, int from_tty
)
1390 int i
, alias_argc
, command_argc
;
1391 int abbrev_flag
= 0;
1393 const char *alias
, *command
;
1395 if (args
== NULL
|| strchr (args
, '=') == NULL
)
1396 alias_usage_error ();
1398 equals
= strchr (args
, '=');
1399 std::string
args2 (args
, equals
- args
);
1401 gdb_argv
built_alias_argv (args2
.c_str ());
1402 gdb_argv
command_argv (equals
+ 1);
1404 char **alias_argv
= built_alias_argv
.get ();
1405 while (alias_argv
[0] != NULL
)
1407 if (strcmp (alias_argv
[0], "-a") == 0)
1412 else if (strcmp (alias_argv
[0], "--") == 0)
1421 if (alias_argv
[0] == NULL
|| command_argv
[0] == NULL
1422 || *alias_argv
[0] == '\0' || *command_argv
[0] == '\0')
1423 alias_usage_error ();
1425 for (i
= 0; alias_argv
[i
] != NULL
; ++i
)
1427 if (! valid_user_defined_cmd_name_p (alias_argv
[i
]))
1430 error (_("Invalid command name: %s"), alias_argv
[i
]);
1432 error (_("Invalid command element name: %s"), alias_argv
[i
]);
1436 alias_argc
= countargv (alias_argv
);
1437 command_argc
= command_argv
.count ();
1439 /* COMMAND must exist.
1440 Reconstruct the command to remove any extraneous spaces,
1441 for better error messages. */
1442 std::string
command_string (argv_to_string (command_argv
.get (),
1444 command
= command_string
.c_str ();
1445 if (! valid_command_p (command
))
1446 error (_("Invalid command to alias to: %s"), command
);
1448 /* ALIAS must not exist. */
1449 std::string
alias_string (argv_to_string (alias_argv
, alias_argc
));
1450 alias
= alias_string
.c_str ();
1451 if (valid_command_p (alias
))
1452 error (_("Alias already exists: %s"), alias
);
1454 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1455 Example: alias spe = set print elements
1457 Otherwise ALIAS and COMMAND must have the same number of words,
1458 and every word except the last must match; and the last word of
1459 ALIAS is made an alias of the last word of COMMAND.
1460 Example: alias set print elms = set pr elem
1461 Note that unambiguous abbreviations are allowed. */
1463 if (alias_argc
== 1)
1465 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1466 add_com_alias (xstrdup (alias_argv
[0]), command
, class_alias
,
1471 const char *alias_prefix
, *command_prefix
;
1472 struct cmd_list_element
*c_alias
, *c_command
;
1474 if (alias_argc
!= command_argc
)
1475 error (_("Mismatched command length between ALIAS and COMMAND."));
1477 /* Create copies of ALIAS and COMMAND without the last word,
1478 and use that to verify the leading elements match. */
1479 std::string
alias_prefix_string (argv_to_string (alias_argv
,
1481 std::string
command_prefix_string (argv_to_string (alias_argv
,
1483 alias_prefix
= alias_prefix_string
.c_str ();
1484 command_prefix
= command_prefix_string
.c_str ();
1486 c_command
= lookup_cmd_1 (& command_prefix
, cmdlist
, NULL
, 1);
1487 /* We've already tried to look up COMMAND. */
1488 gdb_assert (c_command
!= NULL
1489 && c_command
!= (struct cmd_list_element
*) -1);
1490 gdb_assert (c_command
->prefixlist
!= NULL
);
1491 c_alias
= lookup_cmd_1 (& alias_prefix
, cmdlist
, NULL
, 1);
1492 if (c_alias
!= c_command
)
1493 error (_("ALIAS and COMMAND prefixes do not match."));
1495 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1496 add_alias_cmd (xstrdup (alias_argv
[alias_argc
- 1]),
1497 command_argv
[command_argc
- 1],
1498 class_alias
, abbrev_flag
, c_command
->prefixlist
);
1502 /* Print the file / line number / symbol name of the location
1503 specified by SAL. */
1506 print_sal_location (const symtab_and_line
&sal
)
1508 scoped_restore_current_program_space restore_pspace
;
1509 set_current_program_space (sal
.pspace
);
1511 const char *sym_name
= NULL
;
1512 if (sal
.symbol
!= NULL
)
1513 sym_name
= SYMBOL_PRINT_NAME (sal
.symbol
);
1514 printf_filtered (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
1515 symtab_to_filename_for_display (sal
.symtab
),
1516 sal
.line
, sym_name
!= NULL
? sym_name
: "???");
1519 /* Print a list of files and line numbers which a user may choose from
1520 in order to list a function which was specified ambiguously (as
1521 with `list classname::overloadedfuncname', for example). The SALS
1522 array provides the filenames and line numbers. FORMAT is a
1523 printf-style format string used to tell the user what was
1527 ambiguous_line_spec (gdb::array_view
<const symtab_and_line
> sals
,
1528 const char *format
, ...)
1531 va_start (ap
, format
);
1532 vprintf_filtered (format
, ap
);
1535 for (const auto &sal
: sals
)
1536 print_sal_location (sal
);
1539 /* Comparison function for filter_sals. Returns a qsort-style
1543 cmp_symtabs (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1545 const char *dira
= SYMTAB_DIRNAME (sala
.symtab
);
1546 const char *dirb
= SYMTAB_DIRNAME (salb
.symtab
);
1554 else if (dirb
== NULL
)
1561 r
= filename_cmp (dira
, dirb
);
1566 r
= filename_cmp (sala
.symtab
->filename
, salb
.symtab
->filename
);
1570 if (sala
.line
< salb
.line
)
1572 return sala
.line
== salb
.line
? 0 : 1;
1575 /* Remove any SALs that do not match the current program space, or
1576 which appear to be "file:line" duplicates. */
1579 filter_sals (std::vector
<symtab_and_line
> &sals
)
1581 /* Remove SALs that do not match. */
1582 auto from
= std::remove_if (sals
.begin (), sals
.end (),
1583 [&] (const symtab_and_line
&sal
)
1584 { return (sal
.pspace
!= current_program_space
|| sal
.symtab
== NULL
); });
1587 std::sort (sals
.begin (), from
,
1588 [] (const symtab_and_line
&sala
, const symtab_and_line
&salb
)
1589 { return cmp_symtabs (sala
, salb
) < 0; });
1591 from
= std::unique (sals
.begin (), from
,
1592 [&] (const symtab_and_line
&sala
,
1593 const symtab_and_line
&salb
)
1594 { return cmp_symtabs (sala
, salb
) == 0; });
1596 sals
.erase (from
, sals
.end ());
1600 set_debug (const char *arg
, int from_tty
)
1602 printf_unfiltered (_("\"set debug\" must be followed by "
1603 "the name of a debug subcommand.\n"));
1604 help_list (setdebuglist
, "set debug ", all_commands
, gdb_stdout
);
1608 show_debug (const char *args
, int from_tty
)
1610 cmd_show_list (showdebuglist
, from_tty
, "");
1614 init_cmd_lists (void)
1616 max_user_call_depth
= 1024;
1620 show_info_verbose (struct ui_file
*file
, int from_tty
,
1621 struct cmd_list_element
*c
,
1625 fprintf_filtered (file
,
1626 _("Verbose printing of informational messages is %s.\n"),
1629 fprintf_filtered (file
, _("Verbosity is %s.\n"), value
);
1633 show_history_expansion_p (struct ui_file
*file
, int from_tty
,
1634 struct cmd_list_element
*c
, const char *value
)
1636 fprintf_filtered (file
, _("History expansion on command input is %s.\n"),
1641 show_remote_debug (struct ui_file
*file
, int from_tty
,
1642 struct cmd_list_element
*c
, const char *value
)
1644 fprintf_filtered (file
, _("Debugging of remote protocol is %s.\n"),
1649 show_remote_timeout (struct ui_file
*file
, int from_tty
,
1650 struct cmd_list_element
*c
, const char *value
)
1652 fprintf_filtered (file
,
1653 _("Timeout limit to wait for target to respond is %s.\n"),
1658 show_max_user_call_depth (struct ui_file
*file
, int from_tty
,
1659 struct cmd_list_element
*c
, const char *value
)
1661 fprintf_filtered (file
,
1662 _("The max call depth for user-defined commands is %s.\n"),
1667 _initialize_cli_cmds (void)
1669 struct cmd_list_element
*c
;
1671 /* Define the classes of commands.
1672 They will appear in the help list in alphabetical order. */
1674 add_cmd ("internals", class_maintenance
, _("\
1675 Maintenance commands.\n\
1676 Some gdb commands are provided just for use by gdb maintainers.\n\
1677 These commands are subject to frequent change, and may not be as\n\
1678 well documented as user commands."),
1680 add_cmd ("obscure", class_obscure
, _("Obscure features."), &cmdlist
);
1681 add_cmd ("aliases", class_alias
,
1682 _("Aliases of other commands."), &cmdlist
);
1683 add_cmd ("user-defined", class_user
, _("\
1684 User-defined commands.\n\
1685 The commands in this class are those defined by the user.\n\
1686 Use the \"define\" command to define a command."), &cmdlist
);
1687 add_cmd ("support", class_support
, _("Support facilities."), &cmdlist
);
1689 add_cmd ("status", class_info
, _("Status inquiries."), &cmdlist
);
1690 add_cmd ("files", class_files
, _("Specifying and examining files."),
1692 add_cmd ("breakpoints", class_breakpoint
,
1693 _("Making program stop at certain points."), &cmdlist
);
1694 add_cmd ("data", class_vars
, _("Examining data."), &cmdlist
);
1695 add_cmd ("stack", class_stack
, _("\
1696 Examining the stack.\n\
1697 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
1698 counting from zero for the innermost (currently executing) frame.\n\n\
1699 At any time gdb identifies one frame as the \"selected\" frame.\n\
1700 Variable lookups are done with respect to the selected frame.\n\
1701 When the program being debugged stops, gdb selects the innermost frame.\n\
1702 The commands below can be used to select other frames by number or address."),
1704 add_cmd ("running", class_run
, _("Running the program."), &cmdlist
);
1706 /* Define general commands. */
1708 add_com ("pwd", class_files
, pwd_command
, _("\
1709 Print working directory. This is used for your program as well."));
1711 c
= add_cmd ("cd", class_files
, cd_command
, _("\
1712 Set working directory to DIR for debugger.\n\
1713 The debugger's current working directory specifies where scripts and other\n\
1714 files that can be loaded by GDB are located.\n\
1715 In order to change the inferior's current working directory, the recommended\n\
1716 way is to use the \"set cwd\" command."), &cmdlist
);
1717 set_cmd_completer (c
, filename_completer
);
1719 add_com ("echo", class_support
, echo_command
, _("\
1720 Print a constant string. Give string as argument.\n\
1721 C escape sequences may be used in the argument.\n\
1722 No newline is added at the end of the argument;\n\
1723 use \"\\n\" if you want a newline to be printed.\n\
1724 Since leading and trailing whitespace are ignored in command arguments,\n\
1725 if you want to print some you must use \"\\\" before leading whitespace\n\
1726 to be printed or after trailing whitespace."));
1728 add_setshow_enum_cmd ("script-extension", class_support
,
1729 script_ext_enums
, &script_ext_mode
, _("\
1730 Set mode for script filename extension recognition."), _("\
1731 Show mode for script filename extension recognition."), _("\
1732 off == no filename extension recognition (all sourced files are GDB scripts)\n\
1733 soft == evaluate script according to filename extension, fallback to GDB script"
1735 strict == evaluate script according to filename extension, error if not supported"
1738 show_script_ext_mode
,
1739 &setlist
, &showlist
);
1741 add_com ("quit", class_support
, quit_command
, _("\
1743 Usage: quit [EXPR]\n\
1744 The optional expression EXPR, if present, is evaluated and the result\n\
1745 used as GDB's exit code. The default is zero."));
1746 c
= add_com ("help", class_support
, help_command
,
1747 _("Print list of commands."));
1748 set_cmd_completer (c
, command_completer
);
1749 add_com_alias ("q", "quit", class_support
, 1);
1750 add_com_alias ("h", "help", class_support
, 1);
1752 add_setshow_boolean_cmd ("verbose", class_support
, &info_verbose
, _("\
1753 Set verbosity."), _("\
1754 Show verbosity."), NULL
,
1757 &setlist
, &showlist
);
1759 add_prefix_cmd ("history", class_support
, set_history
,
1760 _("Generic command for setting command history parameters."),
1761 &sethistlist
, "set history ", 0, &setlist
);
1762 add_prefix_cmd ("history", class_support
, show_history
,
1763 _("Generic command for showing command history parameters."),
1764 &showhistlist
, "show history ", 0, &showlist
);
1766 add_setshow_boolean_cmd ("expansion", no_class
, &history_expansion_p
, _("\
1767 Set history expansion on command input."), _("\
1768 Show history expansion on command input."), _("\
1769 Without an argument, history expansion is enabled."),
1771 show_history_expansion_p
,
1772 &sethistlist
, &showhistlist
);
1774 add_prefix_cmd ("info", class_info
, info_command
, _("\
1775 Generic command for showing things about the program being debugged."),
1776 &infolist
, "info ", 0, &cmdlist
);
1777 add_com_alias ("i", "info", class_info
, 1);
1778 add_com_alias ("inf", "info", class_info
, 1);
1780 add_com ("complete", class_obscure
, complete_command
,
1781 _("List the completions for the rest of the line as a command."));
1783 add_prefix_cmd ("show", class_info
, show_command
, _("\
1784 Generic command for showing things about the debugger."),
1785 &showlist
, "show ", 0, &cmdlist
);
1786 /* Another way to get at the same thing. */
1787 add_info ("set", show_command
, _("Show all GDB settings."));
1789 add_cmd ("commands", no_set_class
, show_commands
, _("\
1790 Show the history of commands you typed.\n\
1791 You can supply a command number to start with, or a `+' to start after\n\
1792 the previous command number shown."),
1795 add_cmd ("version", no_set_class
, show_version
,
1796 _("Show what version of GDB this is."), &showlist
);
1798 add_cmd ("configuration", no_set_class
, show_configuration
,
1799 _("Show how GDB was configured at build time."), &showlist
);
1801 add_setshow_zinteger_cmd ("remote", no_class
, &remote_debug
, _("\
1802 Set debugging of remote protocol."), _("\
1803 Show debugging of remote protocol."), _("\
1804 When enabled, each packet sent or received with the remote target\n\
1808 &setdebuglist
, &showdebuglist
);
1810 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class
,
1811 &remote_timeout
, _("\
1812 Set timeout limit to wait for target to respond."), _("\
1813 Show timeout limit to wait for target to respond."), _("\
1814 This value is used to set the time limit for gdb to wait for a response\n\
1817 show_remote_timeout
,
1818 &setlist
, &showlist
);
1820 add_prefix_cmd ("debug", no_class
, set_debug
,
1821 _("Generic command for setting gdb debugging flags"),
1822 &setdebuglist
, "set debug ", 0, &setlist
);
1824 add_prefix_cmd ("debug", no_class
, show_debug
,
1825 _("Generic command for showing gdb debugging flags"),
1826 &showdebuglist
, "show debug ", 0, &showlist
);
1828 c
= add_com ("shell", class_support
, shell_command
, _("\
1829 Execute the rest of the line as a shell command.\n\
1830 With no arguments, run an inferior shell."));
1831 set_cmd_completer (c
, filename_completer
);
1833 c
= add_com ("edit", class_files
, edit_command
, _("\
1834 Edit specified file or function.\n\
1835 With no argument, edits file containing most recent line listed.\n\
1836 Editing targets can be specified in these ways:\n\
1837 FILE:LINENUM, to edit at that line in that file,\n\
1838 FUNCTION, to edit at the beginning of that function,\n\
1839 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1840 *ADDRESS, to edit at the line containing that address.\n\
1841 Uses EDITOR environment variable contents as editor (or ex as default)."));
1843 c
->completer
= location_completer
;
1845 add_com ("list", class_files
, list_command
, _("\
1846 List specified function or line.\n\
1847 With no argument, lists ten more lines after or around previous listing.\n\
1848 \"list -\" lists the ten lines before a previous ten-line listing.\n\
1849 One argument specifies a line, and ten lines are listed around that line.\n\
1850 Two arguments with comma between specify starting and ending lines to list.\n\
1851 Lines can be specified in these ways:\n\
1852 LINENUM, to list around that line in current file,\n\
1853 FILE:LINENUM, to list around that line in that file,\n\
1854 FUNCTION, to list around beginning of that function,\n\
1855 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1856 *ADDRESS, to list around the line containing that address.\n\
1857 With two args, if one is empty, it stands for ten lines away from\n\
1860 By default, when a single location is given, display ten lines.\n\
1861 This can be changed using \"set listsize\", and the current value\n\
1862 can be shown using \"show listsize\"."));
1864 add_com_alias ("l", "list", class_files
, 1);
1867 add_com_alias ("file", "list", class_files
, 1);
1869 c
= add_com ("disassemble", class_vars
, disassemble_command
, _("\
1870 Disassemble a specified section of memory.\n\
1871 Default is the function surrounding the pc of the selected frame.\n\
1873 With a /m modifier, source lines are included (if available).\n\
1874 This view is \"source centric\": the output is in source line order,\n\
1875 regardless of any optimization that is present. Only the main source file\n\
1876 is displayed, not those of, e.g., any inlined functions.\n\
1877 This modifier hasn't proved useful in practice and is deprecated\n\
1880 With a /s modifier, source lines are included (if available).\n\
1881 This differs from /m in two important respects:\n\
1882 - the output is still in pc address order, and\n\
1883 - file names and contents for all relevant source files are displayed.\n\
1885 With a /r modifier, raw instructions in hex are included.\n\
1887 With a single argument, the function surrounding that address is dumped.\n\
1888 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
1889 in the form of \"start,end\", or \"start,+length\".\n\
1891 Note that the address is interpreted as an expression, not as a location\n\
1892 like in the \"break\" command.\n\
1893 So, for example, if you want to disassemble function bar in file foo.c\n\
1894 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
1895 set_cmd_completer (c
, location_completer
);
1897 add_com_alias ("!", "shell", class_support
, 0);
1899 c
= add_com ("make", class_support
, make_command
, _("\
1900 Run the ``make'' program using the rest of the line as arguments."));
1901 set_cmd_completer (c
, filename_completer
);
1902 add_cmd ("user", no_class
, show_user
, _("\
1903 Show definitions of non-python/scheme user defined commands.\n\
1904 Argument is the name of the user defined command.\n\
1905 With no argument, show definitions of all user defined commands."), &showlist
);
1906 add_com ("apropos", class_support
, apropos_command
,
1907 _("Search for commands matching a REGEXP"));
1909 add_setshow_uinteger_cmd ("max-user-call-depth", no_class
,
1910 &max_user_call_depth
, _("\
1911 Set the max call depth for non-python/scheme user-defined commands."), _("\
1912 Show the max call depth for non-python/scheme user-defined commands."), NULL
,
1914 show_max_user_call_depth
,
1915 &setlist
, &showlist
);
1917 add_setshow_boolean_cmd ("trace-commands", no_class
, &trace_commands
, _("\
1918 Set tracing of GDB CLI commands."), _("\
1919 Show state of GDB CLI command tracing."), _("\
1920 When 'on', each command is displayed as it is executed."),
1923 &setlist
, &showlist
);
1925 c
= add_com ("alias", class_support
, alias_command
, _("\
1926 Define a new command that is an alias of an existing command.\n\
1927 Usage: alias [-a] [--] ALIAS = COMMAND\n\
1928 ALIAS is the name of the alias command to create.\n\
1929 COMMAND is the command being aliased to.\n\
1930 If \"-a\" is specified, the command is an abbreviation,\n\
1931 and will not appear in help command list output.\n\
1934 Make \"spe\" an alias of \"set print elements\":\n\
1935 alias spe = set print elements\n\
1936 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
1937 alias -a set print elms = set print elements"));
1941 init_cli_cmds (void)
1943 struct cmd_list_element
*c
;
1944 char *source_help_text
;
1946 source_help_text
= xstrprintf (_("\
1947 Read commands from a file named FILE.\n\
1949 Usage: source [-s] [-v] FILE\n\
1950 -s: search for the script in the source search path,\n\
1951 even if FILE contains directories.\n\
1952 -v: each command in FILE is echoed as it is executed.\n\
1954 Note that the file \"%s\" is read automatically in this way\n\
1955 when GDB is started."), gdbinit
);
1956 c
= add_cmd ("source", class_support
, source_command
,
1957 source_help_text
, &cmdlist
);
1958 set_cmd_completer (c
, filename_completer
);