1 /* Print values for GNU debugger GDB.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "gdb_string.h"
31 #include "expression.h"
35 #include "breakpoint.h"
39 #include "symfile.h" /* for overlay functions */
40 #include "objfiles.h" /* ditto */
41 #include "completer.h" /* for completion functions */
43 #include "gdb_assert.h"
48 #include "tui/tui.h" /* For tui_active et.al. */
51 extern int asm_demangle
; /* Whether to demangle syms in asm printouts */
52 extern int addressprint
; /* Whether to print hex addresses in HLL " */
61 /* Last specified output format. */
63 static char last_format
= 'x';
65 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
67 static char last_size
= 'w';
69 /* Default address to examine next. */
71 static CORE_ADDR next_address
;
73 /* Default section to examine next. */
75 static asection
*next_section
;
77 /* Last address examined. */
79 static CORE_ADDR last_examine_address
;
81 /* Contents of last address examined.
82 This is not valid past the end of the `x' command! */
84 static struct value
*last_examine_value
;
86 /* Largest offset between a symbolic value and an address, that will be
87 printed as `0x1234 <symbol+offset>'. */
89 static unsigned int max_symbolic_offset
= UINT_MAX
;
91 /* Append the source filename and linenumber of the symbol when
92 printing a symbolic value as `<symbol at filename:linenum>' if set. */
93 static int print_symbol_filename
= 0;
95 /* Number of auto-display expression currently being displayed.
96 So that we can disable it if we get an error or a signal within it.
97 -1 when not doing one. */
99 int current_display_number
;
101 /* Flag to low-level print routines that this value is being printed
102 in an epoch window. We'd like to pass this as a parameter, but
103 every routine would need to take it. Perhaps we can encapsulate
104 this in the I/O stream once we have GNU stdio. */
110 /* Chain link to next auto-display item. */
111 struct display
*next
;
112 /* Expression to be evaluated and displayed. */
113 struct expression
*exp
;
114 /* Item number of this auto-display item. */
116 /* Display format specified. */
117 struct format_data format
;
118 /* Innermost block required by this expression when evaluated */
120 /* Status of this display (enabled or disabled) */
124 /* Chain of expressions whose values should be displayed
125 automatically each time the program stops. */
127 static struct display
*display_chain
;
129 static int display_number
;
131 /* Prototypes for exported functions. */
133 void output_command (char *, int);
135 void _initialize_printcmd (void);
137 /* Prototypes for local functions. */
139 static void delete_display (int);
141 static void enable_display (char *, int);
143 static void disable_display_command (char *, int);
145 static void printf_command (char *, int);
147 static void display_info (char *, int);
149 static void do_one_display (struct display
*);
151 static void undisplay_command (char *, int);
153 static void free_display (struct display
*);
155 static void display_command (char *, int);
157 void x_command (char *, int);
159 static void address_info (char *, int);
161 static void set_command (char *, int);
163 static void call_command (char *, int);
165 static void inspect_command (char *, int);
167 static void print_command (char *, int);
169 static void print_command_1 (char *, int, int);
171 static void validate_format (struct format_data
, char *);
173 static void do_examine (struct format_data
, CORE_ADDR addr
,
176 static void print_formatted (struct value
*, int, int, struct ui_file
*);
178 static struct format_data
decode_format (char **, int, int);
180 static void sym_info (char *, int);
183 /* Decode a format specification. *STRING_PTR should point to it.
184 OFORMAT and OSIZE are used as defaults for the format and size
185 if none are given in the format specification.
186 If OSIZE is zero, then the size field of the returned value
187 should be set only if a size is explicitly specified by the
189 The structure returned describes all the data
190 found in the specification. In addition, *STRING_PTR is advanced
191 past the specification and past all whitespace following it. */
193 static struct format_data
194 decode_format (char **string_ptr
, int oformat
, int osize
)
196 struct format_data val
;
197 char *p
= *string_ptr
;
203 if (*p
>= '0' && *p
<= '9')
204 val
.count
= atoi (p
);
205 while (*p
>= '0' && *p
<= '9')
208 /* Now process size or format letters that follow. */
212 if (*p
== 'b' || *p
== 'h' || *p
== 'w' || *p
== 'g')
214 else if (*p
>= 'a' && *p
<= 'z')
220 while (*p
== ' ' || *p
== '\t')
224 /* Set defaults for format and size if not specified. */
225 if (val
.format
== '?')
229 /* Neither has been specified. */
230 val
.format
= oformat
;
234 /* If a size is specified, any format makes a reasonable
235 default except 'i'. */
236 val
.format
= oformat
== 'i' ? 'x' : oformat
;
238 else if (val
.size
== '?')
243 /* Pick the appropriate size for an address. */
244 if (TARGET_PTR_BIT
== 64)
245 val
.size
= osize
? 'g' : osize
;
246 else if (TARGET_PTR_BIT
== 32)
247 val
.size
= osize
? 'w' : osize
;
248 else if (TARGET_PTR_BIT
== 16)
249 val
.size
= osize
? 'h' : osize
;
251 /* Bad value for TARGET_PTR_BIT */
252 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
255 /* Floating point has to be word or giantword. */
256 if (osize
== 'w' || osize
== 'g')
259 /* Default it to giantword if the last used size is not
261 val
.size
= osize
? 'g' : osize
;
264 /* Characters default to one byte. */
265 val
.size
= osize
? 'b' : osize
;
268 /* The default is the size most recently specified. */
275 /* Print value VAL on stream according to FORMAT, a letter or 0.
276 Do not end with a newline.
277 0 means print VAL according to its own type.
278 SIZE is the letter for the size of datum being printed.
279 This is used to pad hex numbers so they line up. */
282 print_formatted (struct value
*val
, int format
, int size
,
283 struct ui_file
*stream
)
285 struct type
*type
= check_typedef (VALUE_TYPE (val
));
286 int len
= TYPE_LENGTH (type
);
288 if (VALUE_LVAL (val
) == lval_memory
)
290 next_address
= VALUE_ADDRESS (val
) + len
;
291 next_section
= VALUE_BFD_SECTION (val
);
297 /* FIXME: Need to handle wchar_t's here... */
298 next_address
= VALUE_ADDRESS (val
)
299 + val_print_string (VALUE_ADDRESS (val
), -1, 1, stream
);
300 next_section
= VALUE_BFD_SECTION (val
);
304 /* The old comment says
305 "Force output out, print_insn not using _filtered".
306 I'm not completely sure what that means, I suspect most print_insn
307 now do use _filtered, so I guess it's obsolete.
308 --Yes, it does filter now, and so this is obsolete. -JB */
310 /* We often wrap here if there are long symbolic names. */
312 next_address
= VALUE_ADDRESS (val
)
313 + gdb_print_insn (VALUE_ADDRESS (val
), stream
);
314 next_section
= VALUE_BFD_SECTION (val
);
319 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
320 || TYPE_CODE (type
) == TYPE_CODE_STRING
321 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
322 || TYPE_CODE (type
) == TYPE_CODE_UNION
323 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
324 /* If format is 0, use the 'natural' format for
325 * that type of value. If the type is non-scalar,
326 * we have to use language rules to print it as
327 * a series of scalars.
329 value_print (val
, stream
, format
, Val_pretty_default
);
331 /* User specified format, so don't look to the
332 * the type to tell us what to do.
334 print_scalar_formatted (VALUE_CONTENTS (val
), type
,
335 format
, size
, stream
);
339 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
340 according to letters FORMAT and SIZE on STREAM.
341 FORMAT may not be zero. Formats s and i are not supported at this level.
343 This is how the elements of an array or structure are printed
347 print_scalar_formatted (void *valaddr
, struct type
*type
, int format
, int size
,
348 struct ui_file
*stream
)
350 LONGEST val_long
= 0;
351 unsigned int len
= TYPE_LENGTH (type
);
354 val_long
= unpack_long (type
, valaddr
);
356 /* If the value is a pointer, and pointers and addresses are not the
357 same, then at this point, the value's length (in target bytes) is
358 TARGET_ADDR_BIT/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
359 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
360 len
= TARGET_ADDR_BIT
/ TARGET_CHAR_BIT
;
362 /* If we are printing it as unsigned, truncate it in case it is actually
363 a negative signed value (e.g. "print/u (short)-1" should print 65535
364 (if shorts are 16 bits) instead of 4294967295). */
367 if (len
< sizeof (LONGEST
))
368 val_long
&= ((LONGEST
) 1 << HOST_CHAR_BIT
* len
) - 1;
376 /* no size specified, like in print. Print varying # of digits. */
377 print_longest (stream
, 'x', 1, val_long
);
386 print_longest (stream
, size
, 1, val_long
);
389 error ("Undefined output size \"%c\".", size
);
394 print_longest (stream
, 'd', 1, val_long
);
398 print_longest (stream
, 'u', 0, val_long
);
403 print_longest (stream
, 'o', 1, val_long
);
405 fprintf_filtered (stream
, "0");
410 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
411 print_address (addr
, stream
);
416 value_print (value_from_longest (builtin_type_true_char
, val_long
),
417 stream
, 0, Val_pretty_default
);
421 if (len
== TYPE_LENGTH (builtin_type_float
))
422 type
= builtin_type_float
;
423 else if (len
== TYPE_LENGTH (builtin_type_double
))
424 type
= builtin_type_double
;
425 else if (len
== TYPE_LENGTH (builtin_type_long_double
))
426 type
= builtin_type_long_double
;
427 print_floating (valaddr
, type
, stream
);
431 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
434 /* Binary; 't' stands for "two". */
436 char bits
[8 * (sizeof val_long
) + 1];
437 char buf
[8 * (sizeof val_long
) + 32];
442 width
= 8 * (sizeof val_long
);
459 error ("Undefined output size \"%c\".", size
);
465 bits
[width
] = (val_long
& 1) ? '1' : '0';
470 while (*cp
&& *cp
== '0')
475 strcpy (buf
, local_binary_format_prefix ());
477 strcat (buf
, local_binary_format_suffix ());
478 fputs_filtered (buf
, stream
);
483 error ("Undefined output format \"%c\".", format
);
487 /* Specify default address for `x' command.
488 `info lines' uses this. */
491 set_next_address (CORE_ADDR addr
)
495 /* Make address available to the user as $_. */
496 set_internalvar (lookup_internalvar ("_"),
497 value_from_pointer (lookup_pointer_type (builtin_type_void
),
501 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
502 after LEADIN. Print nothing if no symbolic name is found nearby.
503 Optionally also print source file and line number, if available.
504 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
505 or to interpret it as a possible C++ name and convert it back to source
506 form. However note that DO_DEMANGLE can be overridden by the specific
507 settings of the demangle and asm_demangle variables. */
510 print_address_symbolic (CORE_ADDR addr
, struct ui_file
*stream
, int do_demangle
,
514 char *filename
= NULL
;
519 /* throw away both name and filename */
520 struct cleanup
*cleanup_chain
= make_cleanup (free_current_contents
, &name
);
521 make_cleanup (free_current_contents
, &filename
);
523 if (build_address_symbolic (addr
, do_demangle
, &name
, &offset
, &filename
, &line
, &unmapped
))
525 do_cleanups (cleanup_chain
);
529 fputs_filtered (leadin
, stream
);
531 fputs_filtered ("<*", stream
);
533 fputs_filtered ("<", stream
);
534 fputs_filtered (name
, stream
);
536 fprintf_filtered (stream
, "+%u", (unsigned int) offset
);
538 /* Append source filename and line number if desired. Give specific
539 line # of this addr, if we have it; else line # of the nearest symbol. */
540 if (print_symbol_filename
&& filename
!= NULL
)
543 fprintf_filtered (stream
, " at %s:%d", filename
, line
);
545 fprintf_filtered (stream
, " in %s", filename
);
548 fputs_filtered ("*>", stream
);
550 fputs_filtered (">", stream
);
552 do_cleanups (cleanup_chain
);
555 /* Given an address ADDR return all the elements needed to print the
556 address in a symbolic form. NAME can be mangled or not depending
557 on DO_DEMANGLE (and also on the asm_demangle global variable,
558 manipulated via ''set print asm-demangle''). Return 0 in case of
559 success, when all the info in the OUT paramters is valid. Return 1
562 build_address_symbolic (CORE_ADDR addr
, /* IN */
563 int do_demangle
, /* IN */
564 char **name
, /* OUT */
565 int *offset
, /* OUT */
566 char **filename
, /* OUT */
568 int *unmapped
) /* OUT */
570 struct minimal_symbol
*msymbol
;
571 struct symbol
*symbol
;
572 struct symtab
*symtab
= 0;
573 CORE_ADDR name_location
= 0;
574 asection
*section
= 0;
575 char *name_temp
= "";
577 /* Let's say it is unmapped. */
580 /* Determine if the address is in an overlay, and whether it is
582 if (overlay_debugging
)
584 section
= find_pc_overlay (addr
);
585 if (pc_in_unmapped_range (addr
, section
))
588 addr
= overlay_mapped_address (addr
, section
);
592 /* First try to find the address in the symbol table, then
593 in the minsyms. Take the closest one. */
595 /* This is defective in the sense that it only finds text symbols. So
596 really this is kind of pointless--we should make sure that the
597 minimal symbols have everything we need (by changing that we could
598 save some memory, but for many debug format--ELF/DWARF or
599 anything/stabs--it would be inconvenient to eliminate those minimal
601 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
602 symbol
= find_pc_sect_function (addr
, section
);
606 name_location
= BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
));
607 if (do_demangle
|| asm_demangle
)
608 name_temp
= SYMBOL_PRINT_NAME (symbol
);
610 name_temp
= DEPRECATED_SYMBOL_NAME (symbol
);
615 if (SYMBOL_VALUE_ADDRESS (msymbol
) > name_location
|| symbol
== NULL
)
617 /* The msymbol is closer to the address than the symbol;
618 use the msymbol instead. */
621 name_location
= SYMBOL_VALUE_ADDRESS (msymbol
);
622 if (do_demangle
|| asm_demangle
)
623 name_temp
= SYMBOL_PRINT_NAME (msymbol
);
625 name_temp
= DEPRECATED_SYMBOL_NAME (msymbol
);
628 if (symbol
== NULL
&& msymbol
== NULL
)
631 /* If the nearest symbol is too far away, don't print anything symbolic. */
633 /* For when CORE_ADDR is larger than unsigned int, we do math in
634 CORE_ADDR. But when we detect unsigned wraparound in the
635 CORE_ADDR math, we ignore this test and print the offset,
636 because addr+max_symbolic_offset has wrapped through the end
637 of the address space back to the beginning, giving bogus comparison. */
638 if (addr
> name_location
+ max_symbolic_offset
639 && name_location
+ max_symbolic_offset
> name_location
)
642 *offset
= addr
- name_location
;
644 *name
= xstrdup (name_temp
);
646 if (print_symbol_filename
)
648 struct symtab_and_line sal
;
650 sal
= find_pc_sect_line (addr
, section
, 0);
654 *filename
= xstrdup (sal
.symtab
->filename
);
657 else if (symtab
&& symbol
&& symbol
->line
)
659 *filename
= xstrdup (symtab
->filename
);
660 *line
= symbol
->line
;
664 *filename
= xstrdup (symtab
->filename
);
671 /* Print address ADDR on STREAM. USE_LOCAL means the same thing as for
674 print_address_numeric (CORE_ADDR addr
, int use_local
, struct ui_file
*stream
)
676 /* Truncate address to the size of a target address, avoiding shifts
677 larger or equal than the width of a CORE_ADDR. The local
678 variable ADDR_BIT stops the compiler reporting a shift overflow
679 when it won't occur. */
680 /* NOTE: This assumes that the significant address information is
681 kept in the least significant bits of ADDR - the upper bits were
682 either zero or sign extended. Should ADDRESS_TO_POINTER() or
683 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
685 int addr_bit
= TARGET_ADDR_BIT
;
687 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
688 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
689 print_longest (stream
, 'x', use_local
, (ULONGEST
) addr
);
692 /* Print address ADDR symbolically on STREAM.
693 First print it as a number. Then perhaps print
694 <SYMBOL + OFFSET> after the number. */
697 print_address (CORE_ADDR addr
, struct ui_file
*stream
)
699 print_address_numeric (addr
, 1, stream
);
700 print_address_symbolic (addr
, stream
, asm_demangle
, " ");
703 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
704 controls whether to print the symbolic name "raw" or demangled.
705 Global setting "addressprint" controls whether to print hex address
709 print_address_demangle (CORE_ADDR addr
, struct ui_file
*stream
, int do_demangle
)
713 fprintf_filtered (stream
, "0");
715 else if (addressprint
)
717 print_address_numeric (addr
, 1, stream
);
718 print_address_symbolic (addr
, stream
, do_demangle
, " ");
722 print_address_symbolic (addr
, stream
, do_demangle
, "");
727 /* These are the types that $__ will get after an examine command of one
730 static struct type
*examine_i_type
;
732 static struct type
*examine_b_type
;
733 static struct type
*examine_h_type
;
734 static struct type
*examine_w_type
;
735 static struct type
*examine_g_type
;
737 /* Examine data at address ADDR in format FMT.
738 Fetch it from memory and print on gdb_stdout. */
741 do_examine (struct format_data fmt
, CORE_ADDR addr
, asection
*sect
)
746 struct type
*val_type
= NULL
;
756 /* String or instruction format implies fetch single bytes
757 regardless of the specified size. */
758 if (format
== 's' || format
== 'i')
762 val_type
= examine_i_type
;
763 else if (size
== 'b')
764 val_type
= examine_b_type
;
765 else if (size
== 'h')
766 val_type
= examine_h_type
;
767 else if (size
== 'w')
768 val_type
= examine_w_type
;
769 else if (size
== 'g')
770 val_type
= examine_g_type
;
777 if (format
== 's' || format
== 'i')
780 /* Print as many objects as specified in COUNT, at most maxelts per line,
781 with the address of the next one at the start of each line. */
786 print_address (next_address
, gdb_stdout
);
787 printf_filtered (":");
792 printf_filtered ("\t");
793 /* Note that print_formatted sets next_address for the next
795 last_examine_address
= next_address
;
797 if (last_examine_value
)
798 value_free (last_examine_value
);
800 /* The value to be displayed is not fetched greedily.
801 Instead, to avoid the posibility of a fetched value not
802 being used, its retreval is delayed until the print code
803 uses it. When examining an instruction stream, the
804 disassembler will perform its own memory fetch using just
805 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
806 the disassembler be modified so that LAST_EXAMINE_VALUE
807 is left with the byte sequence from the last complete
808 instruction fetched from memory? */
809 last_examine_value
= value_at_lazy (val_type
, next_address
, sect
);
811 if (last_examine_value
)
812 release_value (last_examine_value
);
814 print_formatted (last_examine_value
, format
, size
, gdb_stdout
);
816 printf_filtered ("\n");
817 gdb_flush (gdb_stdout
);
822 validate_format (struct format_data fmt
, char *cmdname
)
825 error ("Size letters are meaningless in \"%s\" command.", cmdname
);
827 error ("Item count other than 1 is meaningless in \"%s\" command.",
829 if (fmt
.format
== 'i' || fmt
.format
== 's')
830 error ("Format letter \"%c\" is meaningless in \"%s\" command.",
831 fmt
.format
, cmdname
);
834 /* Evaluate string EXP as an expression in the current language and
835 print the resulting value. EXP may contain a format specifier as the
836 first argument ("/x myvar" for example, to print myvar in hex).
840 print_command_1 (char *exp
, int inspect
, int voidprint
)
842 struct expression
*expr
;
843 struct cleanup
*old_chain
= 0;
846 struct format_data fmt
;
849 /* Pass inspect flag to the rest of the print routines in a global (sigh). */
850 inspect_it
= inspect
;
852 if (exp
&& *exp
== '/')
855 fmt
= decode_format (&exp
, last_format
, 0);
856 validate_format (fmt
, "print");
857 last_format
= format
= fmt
.format
;
869 expr
= parse_expression (exp
);
870 old_chain
= make_cleanup (free_current_contents
, &expr
);
872 val
= evaluate_expression (expr
);
875 val
= access_value_history (0);
877 if (voidprint
|| (val
&& VALUE_TYPE (val
) &&
878 TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_VOID
))
880 int histindex
= record_latest_value (val
);
883 annotate_value_history_begin (histindex
, VALUE_TYPE (val
));
885 annotate_value_begin (VALUE_TYPE (val
));
888 printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"", exp
, histindex
);
889 else if (histindex
>= 0)
890 printf_filtered ("$%d = ", histindex
);
893 annotate_value_history_value ();
895 print_formatted (val
, format
, fmt
.size
, gdb_stdout
);
896 printf_filtered ("\n");
899 annotate_value_history_end ();
901 annotate_value_end ();
904 printf_unfiltered ("\") )\030");
908 do_cleanups (old_chain
);
909 inspect_it
= 0; /* Reset print routines to normal */
913 print_command (char *exp
, int from_tty
)
915 print_command_1 (exp
, 0, 1);
918 /* Same as print, except in epoch, it gets its own window */
920 inspect_command (char *exp
, int from_tty
)
922 extern int epoch_interface
;
924 print_command_1 (exp
, epoch_interface
, 1);
927 /* Same as print, except it doesn't print void results. */
929 call_command (char *exp
, int from_tty
)
931 print_command_1 (exp
, 0, 0);
935 output_command (char *exp
, int from_tty
)
937 struct expression
*expr
;
938 struct cleanup
*old_chain
;
941 struct format_data fmt
;
943 if (exp
&& *exp
== '/')
946 fmt
= decode_format (&exp
, 0, 0);
947 validate_format (fmt
, "output");
951 expr
= parse_expression (exp
);
952 old_chain
= make_cleanup (free_current_contents
, &expr
);
954 val
= evaluate_expression (expr
);
956 annotate_value_begin (VALUE_TYPE (val
));
958 print_formatted (val
, format
, fmt
.size
, gdb_stdout
);
960 annotate_value_end ();
963 gdb_flush (gdb_stdout
);
965 do_cleanups (old_chain
);
969 set_command (char *exp
, int from_tty
)
971 struct expression
*expr
= parse_expression (exp
);
972 struct cleanup
*old_chain
=
973 make_cleanup (free_current_contents
, &expr
);
974 evaluate_expression (expr
);
975 do_cleanups (old_chain
);
979 sym_info (char *arg
, int from_tty
)
981 struct minimal_symbol
*msymbol
;
982 struct objfile
*objfile
;
983 struct obj_section
*osect
;
985 CORE_ADDR addr
, sect_addr
;
990 error_no_arg ("address");
992 addr
= parse_and_eval_address (arg
);
993 ALL_OBJSECTIONS (objfile
, osect
)
995 sect
= osect
->the_bfd_section
;
996 sect_addr
= overlay_mapped_address (addr
, sect
);
998 if (osect
->addr
<= sect_addr
&& sect_addr
< osect
->endaddr
&&
999 (msymbol
= lookup_minimal_symbol_by_pc_section (sect_addr
, sect
)))
1002 offset
= sect_addr
- SYMBOL_VALUE_ADDRESS (msymbol
);
1004 printf_filtered ("%s + %u in ",
1005 SYMBOL_PRINT_NAME (msymbol
), offset
);
1007 printf_filtered ("%s in ",
1008 SYMBOL_PRINT_NAME (msymbol
));
1009 if (pc_in_unmapped_range (addr
, sect
))
1010 printf_filtered ("load address range of ");
1011 if (section_is_overlay (sect
))
1012 printf_filtered ("%s overlay ",
1013 section_is_mapped (sect
) ? "mapped" : "unmapped");
1014 printf_filtered ("section %s", sect
->name
);
1015 printf_filtered ("\n");
1019 printf_filtered ("No symbol matches %s.\n", arg
);
1023 address_info (char *exp
, int from_tty
)
1026 struct minimal_symbol
*msymbol
;
1030 CORE_ADDR load_addr
;
1031 int is_a_field_of_this
; /* C++: lookup_symbol sets this to nonzero
1032 if exp is a field of `this'. */
1035 error ("Argument required.");
1037 sym
= lookup_symbol (exp
, get_selected_block (0), VAR_DOMAIN
,
1038 &is_a_field_of_this
, (struct symtab
**) NULL
);
1041 if (is_a_field_of_this
)
1043 printf_filtered ("Symbol \"");
1044 fprintf_symbol_filtered (gdb_stdout
, exp
,
1045 current_language
->la_language
, DMGL_ANSI
);
1046 printf_filtered ("\" is a field of the local class variable ");
1047 if (current_language
->la_language
== language_objc
)
1048 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1050 printf_filtered ("`this'\n");
1054 msymbol
= lookup_minimal_symbol (exp
, NULL
, NULL
);
1056 if (msymbol
!= NULL
)
1058 load_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1060 printf_filtered ("Symbol \"");
1061 fprintf_symbol_filtered (gdb_stdout
, exp
,
1062 current_language
->la_language
, DMGL_ANSI
);
1063 printf_filtered ("\" is at ");
1064 print_address_numeric (load_addr
, 1, gdb_stdout
);
1065 printf_filtered (" in a file compiled without debugging");
1066 section
= SYMBOL_BFD_SECTION (msymbol
);
1067 if (section_is_overlay (section
))
1069 load_addr
= overlay_unmapped_address (load_addr
, section
);
1070 printf_filtered (",\n -- loaded at ");
1071 print_address_numeric (load_addr
, 1, gdb_stdout
);
1072 printf_filtered (" in overlay section %s", section
->name
);
1074 printf_filtered (".\n");
1077 error ("No symbol \"%s\" in current context.", exp
);
1081 printf_filtered ("Symbol \"");
1082 fprintf_symbol_filtered (gdb_stdout
, DEPRECATED_SYMBOL_NAME (sym
),
1083 current_language
->la_language
, DMGL_ANSI
);
1084 printf_filtered ("\" is ");
1085 val
= SYMBOL_VALUE (sym
);
1086 basereg
= SYMBOL_BASEREG (sym
);
1087 section
= SYMBOL_BFD_SECTION (sym
);
1089 switch (SYMBOL_CLASS (sym
))
1092 case LOC_CONST_BYTES
:
1093 printf_filtered ("constant");
1097 printf_filtered ("a label at address ");
1098 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1100 if (section_is_overlay (section
))
1102 load_addr
= overlay_unmapped_address (load_addr
, section
);
1103 printf_filtered (",\n -- loaded at ");
1104 print_address_numeric (load_addr
, 1, gdb_stdout
);
1105 printf_filtered (" in overlay section %s", section
->name
);
1110 case LOC_COMPUTED_ARG
:
1111 /* FIXME: cagney/2004-01-26: It should be possible to
1112 unconditionally call the SYMBOL_OPS method when available.
1113 Unfortunately DWARF 2 stores the frame-base (instead of the
1114 function) location in a function's symbol. Oops! For the
1115 moment enable this when/where applicable. */
1116 SYMBOL_OPS (sym
)->describe_location (sym
, gdb_stdout
);
1120 printf_filtered ("a variable in register %s", REGISTER_NAME (val
));
1124 printf_filtered ("static storage at address ");
1125 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1127 if (section_is_overlay (section
))
1129 load_addr
= overlay_unmapped_address (load_addr
, section
);
1130 printf_filtered (",\n -- loaded at ");
1131 print_address_numeric (load_addr
, 1, gdb_stdout
);
1132 printf_filtered (" in overlay section %s", section
->name
);
1137 printf_filtered ("external global (indirect addressing), at address *(");
1138 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1140 printf_filtered (")");
1141 if (section_is_overlay (section
))
1143 load_addr
= overlay_unmapped_address (load_addr
, section
);
1144 printf_filtered (",\n -- loaded at ");
1145 print_address_numeric (load_addr
, 1, gdb_stdout
);
1146 printf_filtered (" in overlay section %s", section
->name
);
1151 printf_filtered ("an argument in register %s", REGISTER_NAME (val
));
1154 case LOC_REGPARM_ADDR
:
1155 printf_filtered ("address of an argument in register %s", REGISTER_NAME (val
));
1159 printf_filtered ("an argument at offset %ld", val
);
1163 printf_filtered ("an argument at frame offset %ld", val
);
1167 printf_filtered ("a local variable at frame offset %ld", val
);
1171 printf_filtered ("a reference argument at offset %ld", val
);
1175 printf_filtered ("a variable at offset %ld from register %s",
1176 val
, REGISTER_NAME (basereg
));
1179 case LOC_BASEREG_ARG
:
1180 printf_filtered ("an argument at offset %ld from register %s",
1181 val
, REGISTER_NAME (basereg
));
1185 printf_filtered ("a typedef");
1189 printf_filtered ("a function at address ");
1190 print_address_numeric (load_addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)),
1192 if (section_is_overlay (section
))
1194 load_addr
= overlay_unmapped_address (load_addr
, section
);
1195 printf_filtered (",\n -- loaded at ");
1196 print_address_numeric (load_addr
, 1, gdb_stdout
);
1197 printf_filtered (" in overlay section %s", section
->name
);
1201 case LOC_UNRESOLVED
:
1203 struct minimal_symbol
*msym
;
1205 msym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym
), NULL
, NULL
);
1207 printf_filtered ("unresolved");
1210 section
= SYMBOL_BFD_SECTION (msym
);
1211 printf_filtered ("static storage at address ");
1212 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (msym
),
1214 if (section_is_overlay (section
))
1216 load_addr
= overlay_unmapped_address (load_addr
, section
);
1217 printf_filtered (",\n -- loaded at ");
1218 print_address_numeric (load_addr
, 1, gdb_stdout
);
1219 printf_filtered (" in overlay section %s", section
->name
);
1225 case LOC_HP_THREAD_LOCAL_STATIC
:
1227 "a thread-local variable at offset %ld from the thread base register %s",
1228 val
, REGISTER_NAME (basereg
));
1231 case LOC_OPTIMIZED_OUT
:
1232 printf_filtered ("optimized out");
1236 printf_filtered ("of unknown (botched) type");
1239 printf_filtered (".\n");
1243 x_command (char *exp
, int from_tty
)
1245 struct expression
*expr
;
1246 struct format_data fmt
;
1247 struct cleanup
*old_chain
;
1250 fmt
.format
= last_format
;
1251 fmt
.size
= last_size
;
1254 if (exp
&& *exp
== '/')
1257 fmt
= decode_format (&exp
, last_format
, last_size
);
1260 /* If we have an expression, evaluate it and use it as the address. */
1262 if (exp
!= 0 && *exp
!= 0)
1264 expr
= parse_expression (exp
);
1265 /* Cause expression not to be there any more
1266 if this command is repeated with Newline.
1267 But don't clobber a user-defined command's definition. */
1270 old_chain
= make_cleanup (free_current_contents
, &expr
);
1271 val
= evaluate_expression (expr
);
1272 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_REF
)
1273 val
= value_ind (val
);
1274 /* In rvalue contexts, such as this, functions are coerced into
1275 pointers to functions. This makes "x/i main" work. */
1276 if (/* last_format == 'i' && */
1277 TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FUNC
1278 && VALUE_LVAL (val
) == lval_memory
)
1279 next_address
= VALUE_ADDRESS (val
);
1281 next_address
= value_as_address (val
);
1282 if (VALUE_BFD_SECTION (val
))
1283 next_section
= VALUE_BFD_SECTION (val
);
1284 do_cleanups (old_chain
);
1287 do_examine (fmt
, next_address
, next_section
);
1289 /* If the examine succeeds, we remember its size and format for next time. */
1290 last_size
= fmt
.size
;
1291 last_format
= fmt
.format
;
1293 /* Set a couple of internal variables if appropriate. */
1294 if (last_examine_value
)
1296 /* Make last address examined available to the user as $_. Use
1297 the correct pointer type. */
1298 struct type
*pointer_type
1299 = lookup_pointer_type (VALUE_TYPE (last_examine_value
));
1300 set_internalvar (lookup_internalvar ("_"),
1301 value_from_pointer (pointer_type
,
1302 last_examine_address
));
1304 /* Make contents of last address examined available to the user as $__. */
1305 /* If the last value has not been fetched from memory then don't
1306 fetch it now - instead mark it by voiding the $__ variable. */
1307 if (VALUE_LAZY (last_examine_value
))
1308 set_internalvar (lookup_internalvar ("__"),
1309 allocate_value (builtin_type_void
));
1311 set_internalvar (lookup_internalvar ("__"), last_examine_value
);
1316 /* Add an expression to the auto-display chain.
1317 Specify the expression. */
1320 display_command (char *exp
, int from_tty
)
1322 struct format_data fmt
;
1323 struct expression
*expr
;
1324 struct display
*new;
1328 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1330 if (tui_active
&& exp
!= NULL
&& *exp
== '$')
1331 display_it
= (tui_set_layout_for_display_command (exp
) == TUI_FAILURE
);
1345 fmt
= decode_format (&exp
, 0, 0);
1346 if (fmt
.size
&& fmt
.format
== 0)
1348 if (fmt
.format
== 'i' || fmt
.format
== 's')
1358 innermost_block
= 0;
1359 expr
= parse_expression (exp
);
1361 new = (struct display
*) xmalloc (sizeof (struct display
));
1364 new->block
= innermost_block
;
1365 new->next
= display_chain
;
1366 new->number
= ++display_number
;
1369 display_chain
= new;
1371 if (from_tty
&& target_has_execution
)
1372 do_one_display (new);
1379 free_display (struct display
*d
)
1385 /* Clear out the display_chain.
1386 Done when new symtabs are loaded, since this invalidates
1387 the types stored in many expressions. */
1390 clear_displays (void)
1394 while ((d
= display_chain
) != NULL
)
1397 display_chain
= d
->next
;
1402 /* Delete the auto-display number NUM. */
1405 delete_display (int num
)
1407 struct display
*d1
, *d
;
1410 error ("No display number %d.", num
);
1412 if (display_chain
->number
== num
)
1415 display_chain
= d1
->next
;
1419 for (d
= display_chain
;; d
= d
->next
)
1422 error ("No display number %d.", num
);
1423 if (d
->next
->number
== num
)
1433 /* Delete some values from the auto-display chain.
1434 Specify the element numbers. */
1437 undisplay_command (char *args
, int from_tty
)
1445 if (query ("Delete all auto-display expressions? "))
1454 while (*p1
>= '0' && *p1
<= '9')
1456 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1457 error ("Arguments must be display numbers.");
1461 delete_display (num
);
1464 while (*p
== ' ' || *p
== '\t')
1470 /* Display a single auto-display.
1471 Do nothing if the display cannot be printed in the current context,
1472 or if the display is disabled. */
1475 do_one_display (struct display
*d
)
1477 int within_current_scope
;
1479 if (d
->enabled_p
== 0)
1483 within_current_scope
= contained_in (get_selected_block (0), d
->block
);
1485 within_current_scope
= 1;
1486 if (!within_current_scope
)
1489 current_display_number
= d
->number
;
1491 annotate_display_begin ();
1492 printf_filtered ("%d", d
->number
);
1493 annotate_display_number_end ();
1494 printf_filtered (": ");
1500 annotate_display_format ();
1502 printf_filtered ("x/");
1503 if (d
->format
.count
!= 1)
1504 printf_filtered ("%d", d
->format
.count
);
1505 printf_filtered ("%c", d
->format
.format
);
1506 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1507 printf_filtered ("%c", d
->format
.size
);
1508 printf_filtered (" ");
1510 annotate_display_expression ();
1512 print_expression (d
->exp
, gdb_stdout
);
1513 annotate_display_expression_end ();
1515 if (d
->format
.count
!= 1)
1516 printf_filtered ("\n");
1518 printf_filtered (" ");
1520 val
= evaluate_expression (d
->exp
);
1521 addr
= value_as_address (val
);
1522 if (d
->format
.format
== 'i')
1523 addr
= ADDR_BITS_REMOVE (addr
);
1525 annotate_display_value ();
1527 do_examine (d
->format
, addr
, VALUE_BFD_SECTION (val
));
1531 annotate_display_format ();
1533 if (d
->format
.format
)
1534 printf_filtered ("/%c ", d
->format
.format
);
1536 annotate_display_expression ();
1538 print_expression (d
->exp
, gdb_stdout
);
1539 annotate_display_expression_end ();
1541 printf_filtered (" = ");
1543 annotate_display_expression ();
1545 print_formatted (evaluate_expression (d
->exp
),
1546 d
->format
.format
, d
->format
.size
, gdb_stdout
);
1547 printf_filtered ("\n");
1550 annotate_display_end ();
1552 gdb_flush (gdb_stdout
);
1553 current_display_number
= -1;
1556 /* Display all of the values on the auto-display chain which can be
1557 evaluated in the current scope. */
1564 for (d
= display_chain
; d
; d
= d
->next
)
1568 /* Delete the auto-display which we were in the process of displaying.
1569 This is done when there is an error or a signal. */
1572 disable_display (int num
)
1576 for (d
= display_chain
; d
; d
= d
->next
)
1577 if (d
->number
== num
)
1582 printf_unfiltered ("No display number %d.\n", num
);
1586 disable_current_display (void)
1588 if (current_display_number
>= 0)
1590 disable_display (current_display_number
);
1591 fprintf_unfiltered (gdb_stderr
, "Disabling display %d to avoid infinite recursion.\n",
1592 current_display_number
);
1594 current_display_number
= -1;
1598 display_info (char *ignore
, int from_tty
)
1603 printf_unfiltered ("There are no auto-display expressions now.\n");
1605 printf_filtered ("Auto-display expressions now in effect:\n\
1606 Num Enb Expression\n");
1608 for (d
= display_chain
; d
; d
= d
->next
)
1610 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
1612 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
1614 else if (d
->format
.format
)
1615 printf_filtered ("/%c ", d
->format
.format
);
1616 print_expression (d
->exp
, gdb_stdout
);
1617 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
))
1618 printf_filtered (" (cannot be evaluated in the current context)");
1619 printf_filtered ("\n");
1620 gdb_flush (gdb_stdout
);
1625 enable_display (char *args
, int from_tty
)
1634 for (d
= display_chain
; d
; d
= d
->next
)
1641 while (*p1
>= '0' && *p1
<= '9')
1643 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1644 error ("Arguments must be display numbers.");
1648 for (d
= display_chain
; d
; d
= d
->next
)
1649 if (d
->number
== num
)
1654 printf_unfiltered ("No display number %d.\n", num
);
1657 while (*p
== ' ' || *p
== '\t')
1663 disable_display_command (char *args
, int from_tty
)
1671 for (d
= display_chain
; d
; d
= d
->next
)
1678 while (*p1
>= '0' && *p1
<= '9')
1680 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1681 error ("Arguments must be display numbers.");
1683 disable_display (atoi (p
));
1686 while (*p
== ' ' || *p
== '\t')
1692 /* Print the value in stack frame FRAME of a variable
1693 specified by a struct symbol. */
1696 print_variable_value (struct symbol
*var
, struct frame_info
*frame
,
1697 struct ui_file
*stream
)
1699 struct value
*val
= read_var_value (var
, frame
);
1701 value_print (val
, stream
, 0, Val_pretty_default
);
1705 printf_command (char *arg
, int from_tty
)
1709 char *string
= NULL
;
1710 struct value
**val_args
;
1712 char *current_substring
;
1714 int allocated_args
= 20;
1715 struct cleanup
*old_cleanups
;
1717 val_args
= (struct value
**) xmalloc (allocated_args
1718 * sizeof (struct value
*));
1719 old_cleanups
= make_cleanup (free_current_contents
, &val_args
);
1722 error_no_arg ("format-control string and values to print");
1724 /* Skip white space before format string */
1725 while (*s
== ' ' || *s
== '\t')
1728 /* A format string should follow, enveloped in double quotes */
1730 error ("Bad format string, missing '\"'.");
1732 /* Parse the format-control string and copy it into the string STRING,
1733 processing some kinds of escape sequence. */
1735 f
= string
= (char *) alloca (strlen (s
) + 1);
1743 error ("Bad format string, non-terminated '\"'.");
1776 /* ??? TODO: handle other escape sequences */
1777 error ("Unrecognized escape character \\%c in format string.",
1787 /* Skip over " and following space and comma. */
1790 while (*s
== ' ' || *s
== '\t')
1793 if (*s
!= ',' && *s
!= 0)
1794 error ("Invalid argument syntax");
1798 while (*s
== ' ' || *s
== '\t')
1801 /* Need extra space for the '\0's. Doubling the size is sufficient. */
1802 substrings
= alloca (strlen (string
) * 2);
1803 current_substring
= substrings
;
1806 /* Now scan the string for %-specs and see what kinds of args they want.
1807 argclass[I] classifies the %-specs so we can give printf_filtered
1808 something of the right size. */
1812 no_arg
, int_arg
, string_arg
, double_arg
, long_long_arg
1814 enum argclass
*argclass
;
1815 enum argclass this_argclass
;
1821 argclass
= (enum argclass
*) alloca (strlen (s
) * sizeof *argclass
);
1829 while (strchr ("0123456789.hlL-+ #", *f
))
1831 if (*f
== 'l' || *f
== 'L')
1838 this_argclass
= string_arg
;
1844 this_argclass
= double_arg
;
1848 error ("`*' not supported for precision or width in printf");
1851 error ("Format specifier `n' not supported in printf");
1854 this_argclass
= no_arg
;
1859 this_argclass
= long_long_arg
;
1861 this_argclass
= int_arg
;
1865 if (this_argclass
!= no_arg
)
1867 strncpy (current_substring
, last_arg
, f
- last_arg
);
1868 current_substring
+= f
- last_arg
;
1869 *current_substring
++ = '\0';
1871 argclass
[nargs_wanted
++] = this_argclass
;
1875 /* Now, parse all arguments and evaluate them.
1876 Store the VALUEs in VAL_ARGS. */
1881 if (nargs
== allocated_args
)
1882 val_args
= (struct value
**) xrealloc ((char *) val_args
,
1883 (allocated_args
*= 2)
1884 * sizeof (struct value
*));
1886 val_args
[nargs
] = parse_to_comma_and_eval (&s1
);
1888 /* If format string wants a float, unchecked-convert the value to
1889 floating point of the same size */
1891 if (argclass
[nargs
] == double_arg
)
1893 struct type
*type
= VALUE_TYPE (val_args
[nargs
]);
1894 if (TYPE_LENGTH (type
) == sizeof (float))
1895 VALUE_TYPE (val_args
[nargs
]) = builtin_type_float
;
1896 if (TYPE_LENGTH (type
) == sizeof (double))
1897 VALUE_TYPE (val_args
[nargs
]) = builtin_type_double
;
1905 if (nargs
!= nargs_wanted
)
1906 error ("Wrong number of arguments for specified format-string");
1908 /* Now actually print them. */
1909 current_substring
= substrings
;
1910 for (i
= 0; i
< nargs
; i
++)
1912 switch (argclass
[i
])
1919 tem
= value_as_address (val_args
[i
]);
1921 /* This is a %s argument. Find the length of the string. */
1926 read_memory (tem
+ j
, &c
, 1);
1931 /* Copy the string contents into a string inside GDB. */
1932 str
= (char *) alloca (j
+ 1);
1934 read_memory (tem
, str
, j
);
1937 printf_filtered (current_substring
, str
);
1942 double val
= value_as_double (val_args
[i
]);
1943 printf_filtered (current_substring
, val
);
1947 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
1949 long long val
= value_as_long (val_args
[i
]);
1950 printf_filtered (current_substring
, val
);
1954 error ("long long not supported in printf");
1958 /* FIXME: there should be separate int_arg and long_arg. */
1959 long val
= value_as_long (val_args
[i
]);
1960 printf_filtered (current_substring
, val
);
1963 default: /* purecov: deadcode */
1964 error ("internal error in printf_command"); /* purecov: deadcode */
1966 /* Skip to the next substring. */
1967 current_substring
+= strlen (current_substring
) + 1;
1969 /* Print the portion of the format string after the last argument. */
1970 puts_filtered (last_arg
);
1972 do_cleanups (old_cleanups
);
1976 _initialize_printcmd (void)
1978 struct cmd_list_element
*c
;
1980 current_display_number
= -1;
1982 add_info ("address", address_info
,
1983 "Describe where symbol SYM is stored.");
1985 add_info ("symbol", sym_info
,
1986 "Describe what symbol is at location ADDR.\n\
1987 Only for symbols with fixed locations (global or static scope).");
1989 add_com ("x", class_vars
, x_command
,
1990 concat ("Examine memory: x/FMT ADDRESS.\n\
1991 ADDRESS is an expression for the memory address to examine.\n\
1992 FMT is a repeat count followed by a format letter and a size letter.\n\
1993 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
1994 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n",
1995 "Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
1996 The specified number of objects of the specified size are printed\n\
1997 according to the format.\n\n\
1998 Defaults for format and size letters are those previously used.\n\
1999 Default count is 1. Default address is following last thing printed\n\
2000 with this command or \"print\".", NULL
));
2003 add_com ("whereis", class_vars
, whereis_command
,
2004 "Print line number and file of definition of variable.");
2007 add_info ("display", display_info
,
2008 "Expressions to display when program stops, with code numbers.");
2010 add_cmd ("undisplay", class_vars
, undisplay_command
,
2011 "Cancel some expressions to be displayed when program stops.\n\
2012 Arguments are the code numbers of the expressions to stop displaying.\n\
2013 No argument means cancel all automatic-display expressions.\n\
2014 \"delete display\" has the same effect as this command.\n\
2015 Do \"info display\" to see current list of code numbers.",
2018 add_com ("display", class_vars
, display_command
,
2019 "Print value of expression EXP each time the program stops.\n\
2020 /FMT may be used before EXP as in the \"print\" command.\n\
2021 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2022 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2023 and examining is done as in the \"x\" command.\n\n\
2024 With no argument, display all currently requested auto-display expressions.\n\
2025 Use \"undisplay\" to cancel display requests previously made."
2028 add_cmd ("display", class_vars
, enable_display
,
2029 "Enable some expressions to be displayed when program stops.\n\
2030 Arguments are the code numbers of the expressions to resume displaying.\n\
2031 No argument means enable all automatic-display expressions.\n\
2032 Do \"info display\" to see current list of code numbers.", &enablelist
);
2034 add_cmd ("display", class_vars
, disable_display_command
,
2035 "Disable some expressions to be displayed when program stops.\n\
2036 Arguments are the code numbers of the expressions to stop displaying.\n\
2037 No argument means disable all automatic-display expressions.\n\
2038 Do \"info display\" to see current list of code numbers.", &disablelist
);
2040 add_cmd ("display", class_vars
, undisplay_command
,
2041 "Cancel some expressions to be displayed when program stops.\n\
2042 Arguments are the code numbers of the expressions to stop displaying.\n\
2043 No argument means cancel all automatic-display expressions.\n\
2044 Do \"info display\" to see current list of code numbers.", &deletelist
);
2046 add_com ("printf", class_vars
, printf_command
,
2047 "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2048 This is useful for formatted output in user-defined commands.");
2050 add_com ("output", class_vars
, output_command
,
2051 "Like \"print\" but don't put in value history and don't print newline.\n\
2052 This is useful in user-defined commands.");
2054 add_prefix_cmd ("set", class_vars
, set_command
,
2055 concat ("Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2056 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2057 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2058 with $), a register (a few standard names starting with $), or an actual\n\
2059 variable in the program being debugged. EXP is any valid expression.\n",
2060 "Use \"set variable\" for variables with names identical to set subcommands.\n\
2061 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2062 You can see these environment settings with the \"show\" command.", NULL
),
2063 &setlist
, "set ", 1, &cmdlist
);
2065 add_com ("assign", class_vars
, set_command
, concat ("Evaluate expression \
2066 EXP and assign result to variable VAR, using assignment\n\
2067 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2068 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2069 with $), a register (a few standard names starting with $), or an actual\n\
2070 variable in the program being debugged. EXP is any valid expression.\n",
2071 "Use \"set variable\" for variables with names identical to set subcommands.\n\
2072 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2073 You can see these environment settings with the \"show\" command.", NULL
));
2075 /* "call" is the same as "set", but handy for dbx users to call fns. */
2076 c
= add_com ("call", class_vars
, call_command
,
2077 "Call a function in the program.\n\
2078 The argument is the function name and arguments, in the notation of the\n\
2079 current working language. The result is printed and saved in the value\n\
2080 history, if it is not void.");
2081 set_cmd_completer (c
, location_completer
);
2083 add_cmd ("variable", class_vars
, set_command
,
2084 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2085 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2086 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2087 with $), a register (a few standard names starting with $), or an actual\n\
2088 variable in the program being debugged. EXP is any valid expression.\n\
2089 This may usually be abbreviated to simply \"set\".",
2092 c
= add_com ("print", class_vars
, print_command
,
2093 concat ("Print value of expression EXP.\n\
2094 Variables accessible are those of the lexical environment of the selected\n\
2095 stack frame, plus all those whose scope is global or an entire file.\n\
2097 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2098 $$NUM refers to NUM'th value back from the last one.\n\
2099 Names starting with $ refer to registers (with the values they would have\n",
2100 "if the program were to return to the stack frame now selected, restoring\n\
2101 all registers saved by frames farther in) or else to debugger\n\
2102 \"convenience\" variables (any such name not a known register).\n\
2103 Use assignment expressions to give values to convenience variables.\n",
2105 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2106 @ is a binary operator for treating consecutive data objects\n\
2107 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2108 element is FOO, whose second element is stored in the space following\n\
2109 where FOO is stored, etc. FOO must be an expression whose value\n\
2110 resides in memory.\n",
2112 EXP may be preceded with /FMT, where FMT is a format letter\n\
2113 but no count or size letter (see \"x\" command).", NULL
));
2114 set_cmd_completer (c
, location_completer
);
2115 add_com_alias ("p", "print", class_vars
, 1);
2117 c
= add_com ("inspect", class_vars
, inspect_command
,
2118 "Same as \"print\" command, except that if you are running in the epoch\n\
2119 environment, the value is printed in its own window.");
2120 set_cmd_completer (c
, location_completer
);
2123 add_set_cmd ("max-symbolic-offset", no_class
, var_uinteger
,
2124 (char *) &max_symbolic_offset
,
2125 "Set the largest offset that will be printed in <symbol+1234> form.",
2129 add_set_cmd ("symbol-filename", no_class
, var_boolean
,
2130 (char *) &print_symbol_filename
,
2131 "Set printing of source filename and line number with <symbol>.",
2135 /* For examine/instruction a single byte quantity is specified as
2136 the data. This avoids problems with value_at_lazy() requiring a
2137 valid data type (and rejecting VOID). */
2138 examine_i_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_i_type", NULL
);
2140 examine_b_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_b_type", NULL
);
2141 examine_h_type
= init_type (TYPE_CODE_INT
, 2, 0, "examine_h_type", NULL
);
2142 examine_w_type
= init_type (TYPE_CODE_INT
, 4, 0, "examine_w_type", NULL
);
2143 examine_g_type
= init_type (TYPE_CODE_INT
, 8, 0, "examine_g_type", NULL
);