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 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"
47 extern int asm_demangle
; /* Whether to demangle syms in asm printouts */
48 extern int addressprint
; /* Whether to print hex addresses in HLL " */
57 /* Last specified output format. */
59 static char last_format
= 'x';
61 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
63 static char last_size
= 'w';
65 /* Default address to examine next. */
67 static CORE_ADDR next_address
;
69 /* Default section to examine next. */
71 static asection
*next_section
;
73 /* Last address examined. */
75 static CORE_ADDR last_examine_address
;
77 /* Contents of last address examined.
78 This is not valid past the end of the `x' command! */
80 static struct value
*last_examine_value
;
82 /* Largest offset between a symbolic value and an address, that will be
83 printed as `0x1234 <symbol+offset>'. */
85 static unsigned int max_symbolic_offset
= UINT_MAX
;
87 /* Append the source filename and linenumber of the symbol when
88 printing a symbolic value as `<symbol at filename:linenum>' if set. */
89 static int print_symbol_filename
= 0;
91 /* Number of auto-display expression currently being displayed.
92 So that we can disable it if we get an error or a signal within it.
93 -1 when not doing one. */
95 int current_display_number
;
97 /* Flag to low-level print routines that this value is being printed
98 in an epoch window. We'd like to pass this as a parameter, but
99 every routine would need to take it. Perhaps we can encapsulate
100 this in the I/O stream once we have GNU stdio. */
106 /* Chain link to next auto-display item. */
107 struct display
*next
;
108 /* Expression to be evaluated and displayed. */
109 struct expression
*exp
;
110 /* Item number of this auto-display item. */
112 /* Display format specified. */
113 struct format_data format
;
114 /* Innermost block required by this expression when evaluated */
116 /* Status of this display (enabled or disabled) */
120 /* Chain of expressions whose values should be displayed
121 automatically each time the program stops. */
123 static struct display
*display_chain
;
125 static int display_number
;
127 /* Prototypes for exported functions. */
129 void output_command (char *, int);
131 void _initialize_printcmd (void);
133 /* Prototypes for local functions. */
135 static void delete_display (int);
137 static void enable_display (char *, int);
139 static void disable_display_command (char *, int);
141 static void printf_command (char *, int);
143 static void display_info (char *, int);
145 static void do_one_display (struct display
*);
147 static void undisplay_command (char *, int);
149 static void free_display (struct display
*);
151 static void display_command (char *, int);
153 void x_command (char *, int);
155 static void address_info (char *, int);
157 static void set_command (char *, int);
159 static void call_command (char *, int);
161 static void inspect_command (char *, int);
163 static void print_command (char *, int);
165 static void print_command_1 (char *, int, int);
167 static void validate_format (struct format_data
, char *);
169 static void do_examine (struct format_data
, CORE_ADDR addr
,
172 static void print_formatted (struct value
*, int, int, struct ui_file
*);
174 static struct format_data
decode_format (char **, int, int);
176 static void sym_info (char *, int);
179 /* Decode a format specification. *STRING_PTR should point to it.
180 OFORMAT and OSIZE are used as defaults for the format and size
181 if none are given in the format specification.
182 If OSIZE is zero, then the size field of the returned value
183 should be set only if a size is explicitly specified by the
185 The structure returned describes all the data
186 found in the specification. In addition, *STRING_PTR is advanced
187 past the specification and past all whitespace following it. */
189 static struct format_data
190 decode_format (char **string_ptr
, int oformat
, int osize
)
192 struct format_data val
;
193 char *p
= *string_ptr
;
199 if (*p
>= '0' && *p
<= '9')
200 val
.count
= atoi (p
);
201 while (*p
>= '0' && *p
<= '9')
204 /* Now process size or format letters that follow. */
208 if (*p
== 'b' || *p
== 'h' || *p
== 'w' || *p
== 'g')
210 else if (*p
>= 'a' && *p
<= 'z')
216 while (*p
== ' ' || *p
== '\t')
220 /* Set defaults for format and size if not specified. */
221 if (val
.format
== '?')
225 /* Neither has been specified. */
226 val
.format
= oformat
;
230 /* If a size is specified, any format makes a reasonable
231 default except 'i'. */
232 val
.format
= oformat
== 'i' ? 'x' : oformat
;
234 else if (val
.size
== '?')
239 /* Pick the appropriate size for an address. */
240 if (TARGET_PTR_BIT
== 64)
241 val
.size
= osize
? 'g' : osize
;
242 else if (TARGET_PTR_BIT
== 32)
243 val
.size
= osize
? 'w' : osize
;
244 else if (TARGET_PTR_BIT
== 16)
245 val
.size
= osize
? 'h' : osize
;
247 /* Bad value for TARGET_PTR_BIT */
248 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
251 /* Floating point has to be word or giantword. */
252 if (osize
== 'w' || osize
== 'g')
255 /* Default it to giantword if the last used size is not
257 val
.size
= osize
? 'g' : osize
;
260 /* Characters default to one byte. */
261 val
.size
= osize
? 'b' : osize
;
264 /* The default is the size most recently specified. */
271 /* Print value VAL on stream according to FORMAT, a letter or 0.
272 Do not end with a newline.
273 0 means print VAL according to its own type.
274 SIZE is the letter for the size of datum being printed.
275 This is used to pad hex numbers so they line up. */
278 print_formatted (struct value
*val
, int format
, int size
,
279 struct ui_file
*stream
)
281 struct type
*type
= check_typedef (VALUE_TYPE (val
));
282 int len
= TYPE_LENGTH (type
);
284 if (VALUE_LVAL (val
) == lval_memory
)
286 next_address
= VALUE_ADDRESS (val
) + len
;
287 next_section
= VALUE_BFD_SECTION (val
);
293 /* FIXME: Need to handle wchar_t's here... */
294 next_address
= VALUE_ADDRESS (val
)
295 + val_print_string (VALUE_ADDRESS (val
), -1, 1, stream
);
296 next_section
= VALUE_BFD_SECTION (val
);
300 /* The old comment says
301 "Force output out, print_insn not using _filtered".
302 I'm not completely sure what that means, I suspect most print_insn
303 now do use _filtered, so I guess it's obsolete.
304 --Yes, it does filter now, and so this is obsolete. -JB */
306 /* We often wrap here if there are long symbolic names. */
308 next_address
= VALUE_ADDRESS (val
)
309 + gdb_print_insn (VALUE_ADDRESS (val
), stream
);
310 next_section
= VALUE_BFD_SECTION (val
);
315 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
316 || TYPE_CODE (type
) == TYPE_CODE_STRING
317 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
318 || TYPE_CODE (type
) == TYPE_CODE_UNION
319 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
320 /* If format is 0, use the 'natural' format for
321 * that type of value. If the type is non-scalar,
322 * we have to use language rules to print it as
323 * a series of scalars.
325 value_print (val
, stream
, format
, Val_pretty_default
);
327 /* User specified format, so don't look to the
328 * the type to tell us what to do.
330 print_scalar_formatted (VALUE_CONTENTS (val
), type
,
331 format
, size
, stream
);
335 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
336 according to letters FORMAT and SIZE on STREAM.
337 FORMAT may not be zero. Formats s and i are not supported at this level.
339 This is how the elements of an array or structure are printed
343 print_scalar_formatted (void *valaddr
, struct type
*type
, int format
, int size
,
344 struct ui_file
*stream
)
347 unsigned int len
= TYPE_LENGTH (type
);
349 if (len
> sizeof (LONGEST
)
357 if (!TYPE_UNSIGNED (type
)
358 || !extract_long_unsigned_integer (valaddr
, len
, &val_long
))
360 /* We can't print it normally, but we can print it in hex.
361 Printing it in the wrong radix is more useful than saying
362 "use /x, you dummy". */
363 /* FIXME: we could also do octal or binary if that was the
365 /* FIXME: we should be using the size field to give us a
366 minimum field width to print. */
369 print_octal_chars (stream
, valaddr
, len
);
370 else if (format
== 'd')
371 print_decimal_chars (stream
, valaddr
, len
);
372 else if (format
== 't')
373 print_binary_chars (stream
, valaddr
, len
);
375 /* replace with call to print_hex_chars? Looks
376 like val_print_type_code_int is redoing
379 val_print_type_code_int (type
, valaddr
, stream
);
384 /* If we get here, extract_long_unsigned_integer set val_long. */
386 else if (format
!= 'f')
387 val_long
= unpack_long (type
, valaddr
);
389 /* If the value is a pointer, and pointers and addresses are not the
390 same, then at this point, the value's length (in target bytes) is
391 TARGET_ADDR_BIT/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
392 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
393 len
= TARGET_ADDR_BIT
/ TARGET_CHAR_BIT
;
395 /* If we are printing it as unsigned, truncate it in case it is actually
396 a negative signed value (e.g. "print/u (short)-1" should print 65535
397 (if shorts are 16 bits) instead of 4294967295). */
400 if (len
< sizeof (LONGEST
))
401 val_long
&= ((LONGEST
) 1 << HOST_CHAR_BIT
* len
) - 1;
409 /* no size specified, like in print. Print varying # of digits. */
410 print_longest (stream
, 'x', 1, val_long
);
419 print_longest (stream
, size
, 1, val_long
);
422 error ("Undefined output size \"%c\".", size
);
427 print_longest (stream
, 'd', 1, val_long
);
431 print_longest (stream
, 'u', 0, val_long
);
436 print_longest (stream
, 'o', 1, val_long
);
438 fprintf_filtered (stream
, "0");
443 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
444 print_address (addr
, stream
);
449 value_print (value_from_longest (builtin_type_true_char
, val_long
),
450 stream
, 0, Val_pretty_default
);
454 if (len
== TYPE_LENGTH (builtin_type_float
))
455 type
= builtin_type_float
;
456 else if (len
== TYPE_LENGTH (builtin_type_double
))
457 type
= builtin_type_double
;
458 else if (len
== TYPE_LENGTH (builtin_type_long_double
))
459 type
= builtin_type_long_double
;
460 print_floating (valaddr
, type
, stream
);
464 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
467 /* Binary; 't' stands for "two". */
469 char bits
[8 * (sizeof val_long
) + 1];
470 char buf
[8 * (sizeof val_long
) + 32];
475 width
= 8 * (sizeof val_long
);
492 error ("Undefined output size \"%c\".", size
);
498 bits
[width
] = (val_long
& 1) ? '1' : '0';
503 while (*cp
&& *cp
== '0')
508 strcpy (buf
, local_binary_format_prefix ());
510 strcat (buf
, local_binary_format_suffix ());
511 fputs_filtered (buf
, stream
);
516 error ("Undefined output format \"%c\".", format
);
520 /* Specify default address for `x' command.
521 `info lines' uses this. */
524 set_next_address (CORE_ADDR addr
)
528 /* Make address available to the user as $_. */
529 set_internalvar (lookup_internalvar ("_"),
530 value_from_pointer (lookup_pointer_type (builtin_type_void
),
534 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
535 after LEADIN. Print nothing if no symbolic name is found nearby.
536 Optionally also print source file and line number, if available.
537 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
538 or to interpret it as a possible C++ name and convert it back to source
539 form. However note that DO_DEMANGLE can be overridden by the specific
540 settings of the demangle and asm_demangle variables. */
543 print_address_symbolic (CORE_ADDR addr
, struct ui_file
*stream
, int do_demangle
,
547 char *filename
= NULL
;
552 /* throw away both name and filename */
553 struct cleanup
*cleanup_chain
= make_cleanup (free_current_contents
, &name
);
554 make_cleanup (free_current_contents
, &filename
);
556 if (build_address_symbolic (addr
, do_demangle
, &name
, &offset
, &filename
, &line
, &unmapped
))
558 do_cleanups (cleanup_chain
);
562 fputs_filtered (leadin
, stream
);
564 fputs_filtered ("<*", stream
);
566 fputs_filtered ("<", stream
);
567 fputs_filtered (name
, stream
);
569 fprintf_filtered (stream
, "+%u", (unsigned int) offset
);
571 /* Append source filename and line number if desired. Give specific
572 line # of this addr, if we have it; else line # of the nearest symbol. */
573 if (print_symbol_filename
&& filename
!= NULL
)
576 fprintf_filtered (stream
, " at %s:%d", filename
, line
);
578 fprintf_filtered (stream
, " in %s", filename
);
581 fputs_filtered ("*>", stream
);
583 fputs_filtered (">", stream
);
585 do_cleanups (cleanup_chain
);
588 /* Given an address ADDR return all the elements needed to print the
589 address in a symbolic form. NAME can be mangled or not depending
590 on DO_DEMANGLE (and also on the asm_demangle global variable,
591 manipulated via ''set print asm-demangle''). Return 0 in case of
592 success, when all the info in the OUT paramters is valid. Return 1
595 build_address_symbolic (CORE_ADDR addr
, /* IN */
596 int do_demangle
, /* IN */
597 char **name
, /* OUT */
598 int *offset
, /* OUT */
599 char **filename
, /* OUT */
601 int *unmapped
) /* OUT */
603 struct minimal_symbol
*msymbol
;
604 struct symbol
*symbol
;
605 struct symtab
*symtab
= 0;
606 CORE_ADDR name_location
= 0;
607 asection
*section
= 0;
608 char *name_temp
= "";
610 /* Let's say it is unmapped. */
613 /* Determine if the address is in an overlay, and whether it is
615 if (overlay_debugging
)
617 section
= find_pc_overlay (addr
);
618 if (pc_in_unmapped_range (addr
, section
))
621 addr
= overlay_mapped_address (addr
, section
);
625 /* First try to find the address in the symbol table, then
626 in the minsyms. Take the closest one. */
628 /* This is defective in the sense that it only finds text symbols. So
629 really this is kind of pointless--we should make sure that the
630 minimal symbols have everything we need (by changing that we could
631 save some memory, but for many debug format--ELF/DWARF or
632 anything/stabs--it would be inconvenient to eliminate those minimal
634 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
635 symbol
= find_pc_sect_function (addr
, section
);
639 name_location
= BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
));
640 if (do_demangle
|| asm_demangle
)
641 name_temp
= SYMBOL_PRINT_NAME (symbol
);
643 name_temp
= DEPRECATED_SYMBOL_NAME (symbol
);
648 if (SYMBOL_VALUE_ADDRESS (msymbol
) > name_location
|| symbol
== NULL
)
650 /* The msymbol is closer to the address than the symbol;
651 use the msymbol instead. */
654 name_location
= SYMBOL_VALUE_ADDRESS (msymbol
);
655 if (do_demangle
|| asm_demangle
)
656 name_temp
= SYMBOL_PRINT_NAME (msymbol
);
658 name_temp
= DEPRECATED_SYMBOL_NAME (msymbol
);
661 if (symbol
== NULL
&& msymbol
== NULL
)
664 /* If the nearest symbol is too far away, don't print anything symbolic. */
666 /* For when CORE_ADDR is larger than unsigned int, we do math in
667 CORE_ADDR. But when we detect unsigned wraparound in the
668 CORE_ADDR math, we ignore this test and print the offset,
669 because addr+max_symbolic_offset has wrapped through the end
670 of the address space back to the beginning, giving bogus comparison. */
671 if (addr
> name_location
+ max_symbolic_offset
672 && name_location
+ max_symbolic_offset
> name_location
)
675 *offset
= addr
- name_location
;
677 *name
= xstrdup (name_temp
);
679 if (print_symbol_filename
)
681 struct symtab_and_line sal
;
683 sal
= find_pc_sect_line (addr
, section
, 0);
687 *filename
= xstrdup (sal
.symtab
->filename
);
690 else if (symtab
&& symbol
&& symbol
->line
)
692 *filename
= xstrdup (symtab
->filename
);
693 *line
= symbol
->line
;
697 *filename
= xstrdup (symtab
->filename
);
704 /* Print address ADDR on STREAM. USE_LOCAL means the same thing as for
707 print_address_numeric (CORE_ADDR addr
, int use_local
, struct ui_file
*stream
)
709 /* Truncate address to the size of a target address, avoiding shifts
710 larger or equal than the width of a CORE_ADDR. The local
711 variable ADDR_BIT stops the compiler reporting a shift overflow
712 when it won't occur. */
713 /* NOTE: This assumes that the significant address information is
714 kept in the least significant bits of ADDR - the upper bits were
715 either zero or sign extended. Should ADDRESS_TO_POINTER() or
716 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
718 int addr_bit
= TARGET_ADDR_BIT
;
720 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
721 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
722 print_longest (stream
, 'x', use_local
, (ULONGEST
) addr
);
725 /* Print address ADDR symbolically on STREAM.
726 First print it as a number. Then perhaps print
727 <SYMBOL + OFFSET> after the number. */
730 print_address (CORE_ADDR addr
, struct ui_file
*stream
)
732 print_address_numeric (addr
, 1, stream
);
733 print_address_symbolic (addr
, stream
, asm_demangle
, " ");
736 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
737 controls whether to print the symbolic name "raw" or demangled.
738 Global setting "addressprint" controls whether to print hex address
742 print_address_demangle (CORE_ADDR addr
, struct ui_file
*stream
, int do_demangle
)
746 fprintf_filtered (stream
, "0");
748 else if (addressprint
)
750 print_address_numeric (addr
, 1, stream
);
751 print_address_symbolic (addr
, stream
, do_demangle
, " ");
755 print_address_symbolic (addr
, stream
, do_demangle
, "");
760 /* These are the types that $__ will get after an examine command of one
763 static struct type
*examine_i_type
;
765 static struct type
*examine_b_type
;
766 static struct type
*examine_h_type
;
767 static struct type
*examine_w_type
;
768 static struct type
*examine_g_type
;
770 /* Examine data at address ADDR in format FMT.
771 Fetch it from memory and print on gdb_stdout. */
774 do_examine (struct format_data fmt
, CORE_ADDR addr
, asection
*sect
)
779 struct type
*val_type
= NULL
;
789 /* String or instruction format implies fetch single bytes
790 regardless of the specified size. */
791 if (format
== 's' || format
== 'i')
795 val_type
= examine_i_type
;
796 else if (size
== 'b')
797 val_type
= examine_b_type
;
798 else if (size
== 'h')
799 val_type
= examine_h_type
;
800 else if (size
== 'w')
801 val_type
= examine_w_type
;
802 else if (size
== 'g')
803 val_type
= examine_g_type
;
810 if (format
== 's' || format
== 'i')
813 /* Print as many objects as specified in COUNT, at most maxelts per line,
814 with the address of the next one at the start of each line. */
819 print_address (next_address
, gdb_stdout
);
820 printf_filtered (":");
825 printf_filtered ("\t");
826 /* Note that print_formatted sets next_address for the next
828 last_examine_address
= next_address
;
830 if (last_examine_value
)
831 value_free (last_examine_value
);
833 /* The value to be displayed is not fetched greedily.
834 Instead, to avoid the posibility of a fetched value not
835 being used, its retreval is delayed until the print code
836 uses it. When examining an instruction stream, the
837 disassembler will perform its own memory fetch using just
838 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
839 the disassembler be modified so that LAST_EXAMINE_VALUE
840 is left with the byte sequence from the last complete
841 instruction fetched from memory? */
842 last_examine_value
= value_at_lazy (val_type
, next_address
, sect
);
844 if (last_examine_value
)
845 release_value (last_examine_value
);
847 print_formatted (last_examine_value
, format
, size
, gdb_stdout
);
849 printf_filtered ("\n");
850 gdb_flush (gdb_stdout
);
855 validate_format (struct format_data fmt
, char *cmdname
)
858 error ("Size letters are meaningless in \"%s\" command.", cmdname
);
860 error ("Item count other than 1 is meaningless in \"%s\" command.",
862 if (fmt
.format
== 'i' || fmt
.format
== 's')
863 error ("Format letter \"%c\" is meaningless in \"%s\" command.",
864 fmt
.format
, cmdname
);
867 /* Evaluate string EXP as an expression in the current language and
868 print the resulting value. EXP may contain a format specifier as the
869 first argument ("/x myvar" for example, to print myvar in hex).
873 print_command_1 (char *exp
, int inspect
, int voidprint
)
875 struct expression
*expr
;
876 struct cleanup
*old_chain
= 0;
879 struct format_data fmt
;
882 /* Pass inspect flag to the rest of the print routines in a global (sigh). */
883 inspect_it
= inspect
;
885 if (exp
&& *exp
== '/')
888 fmt
= decode_format (&exp
, last_format
, 0);
889 validate_format (fmt
, "print");
890 last_format
= format
= fmt
.format
;
902 expr
= parse_expression (exp
);
903 old_chain
= make_cleanup (free_current_contents
, &expr
);
905 val
= evaluate_expression (expr
);
908 val
= access_value_history (0);
910 if (voidprint
|| (val
&& VALUE_TYPE (val
) &&
911 TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_VOID
))
913 int histindex
= record_latest_value (val
);
916 annotate_value_history_begin (histindex
, VALUE_TYPE (val
));
918 annotate_value_begin (VALUE_TYPE (val
));
921 printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"", exp
, histindex
);
922 else if (histindex
>= 0)
923 printf_filtered ("$%d = ", histindex
);
926 annotate_value_history_value ();
928 print_formatted (val
, format
, fmt
.size
, gdb_stdout
);
929 printf_filtered ("\n");
932 annotate_value_history_end ();
934 annotate_value_end ();
937 printf_unfiltered ("\") )\030");
941 do_cleanups (old_chain
);
942 inspect_it
= 0; /* Reset print routines to normal */
946 print_command (char *exp
, int from_tty
)
948 print_command_1 (exp
, 0, 1);
951 /* Same as print, except in epoch, it gets its own window */
953 inspect_command (char *exp
, int from_tty
)
955 extern int epoch_interface
;
957 print_command_1 (exp
, epoch_interface
, 1);
960 /* Same as print, except it doesn't print void results. */
962 call_command (char *exp
, int from_tty
)
964 print_command_1 (exp
, 0, 0);
968 output_command (char *exp
, int from_tty
)
970 struct expression
*expr
;
971 struct cleanup
*old_chain
;
974 struct format_data fmt
;
976 if (exp
&& *exp
== '/')
979 fmt
= decode_format (&exp
, 0, 0);
980 validate_format (fmt
, "output");
984 expr
= parse_expression (exp
);
985 old_chain
= make_cleanup (free_current_contents
, &expr
);
987 val
= evaluate_expression (expr
);
989 annotate_value_begin (VALUE_TYPE (val
));
991 print_formatted (val
, format
, fmt
.size
, gdb_stdout
);
993 annotate_value_end ();
996 gdb_flush (gdb_stdout
);
998 do_cleanups (old_chain
);
1002 set_command (char *exp
, int from_tty
)
1004 struct expression
*expr
= parse_expression (exp
);
1005 struct cleanup
*old_chain
=
1006 make_cleanup (free_current_contents
, &expr
);
1007 evaluate_expression (expr
);
1008 do_cleanups (old_chain
);
1012 sym_info (char *arg
, int from_tty
)
1014 struct minimal_symbol
*msymbol
;
1015 struct objfile
*objfile
;
1016 struct obj_section
*osect
;
1018 CORE_ADDR addr
, sect_addr
;
1020 unsigned int offset
;
1023 error_no_arg ("address");
1025 addr
= parse_and_eval_address (arg
);
1026 ALL_OBJSECTIONS (objfile
, osect
)
1028 sect
= osect
->the_bfd_section
;
1029 sect_addr
= overlay_mapped_address (addr
, sect
);
1031 if (osect
->addr
<= sect_addr
&& sect_addr
< osect
->endaddr
&&
1032 (msymbol
= lookup_minimal_symbol_by_pc_section (sect_addr
, sect
)))
1035 offset
= sect_addr
- SYMBOL_VALUE_ADDRESS (msymbol
);
1037 printf_filtered ("%s + %u in ",
1038 SYMBOL_PRINT_NAME (msymbol
), offset
);
1040 printf_filtered ("%s in ",
1041 SYMBOL_PRINT_NAME (msymbol
));
1042 if (pc_in_unmapped_range (addr
, sect
))
1043 printf_filtered ("load address range of ");
1044 if (section_is_overlay (sect
))
1045 printf_filtered ("%s overlay ",
1046 section_is_mapped (sect
) ? "mapped" : "unmapped");
1047 printf_filtered ("section %s", sect
->name
);
1048 printf_filtered ("\n");
1052 printf_filtered ("No symbol matches %s.\n", arg
);
1056 address_info (char *exp
, int from_tty
)
1059 struct minimal_symbol
*msymbol
;
1063 CORE_ADDR load_addr
;
1064 int is_a_field_of_this
; /* C++: lookup_symbol sets this to nonzero
1065 if exp is a field of `this'. */
1068 error ("Argument required.");
1070 sym
= lookup_symbol (exp
, get_selected_block (0), VAR_DOMAIN
,
1071 &is_a_field_of_this
, (struct symtab
**) NULL
);
1074 if (is_a_field_of_this
)
1076 printf_filtered ("Symbol \"");
1077 fprintf_symbol_filtered (gdb_stdout
, exp
,
1078 current_language
->la_language
, DMGL_ANSI
);
1079 printf_filtered ("\" is a field of the local class variable ");
1080 if (current_language
->la_language
== language_objc
)
1081 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1083 printf_filtered ("`this'\n");
1087 msymbol
= lookup_minimal_symbol (exp
, NULL
, NULL
);
1089 if (msymbol
!= NULL
)
1091 load_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1093 printf_filtered ("Symbol \"");
1094 fprintf_symbol_filtered (gdb_stdout
, exp
,
1095 current_language
->la_language
, DMGL_ANSI
);
1096 printf_filtered ("\" is at ");
1097 print_address_numeric (load_addr
, 1, gdb_stdout
);
1098 printf_filtered (" in a file compiled without debugging");
1099 section
= SYMBOL_BFD_SECTION (msymbol
);
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
);
1107 printf_filtered (".\n");
1110 error ("No symbol \"%s\" in current context.", exp
);
1114 printf_filtered ("Symbol \"");
1115 fprintf_symbol_filtered (gdb_stdout
, DEPRECATED_SYMBOL_NAME (sym
),
1116 current_language
->la_language
, DMGL_ANSI
);
1117 printf_filtered ("\" is ");
1118 val
= SYMBOL_VALUE (sym
);
1119 basereg
= SYMBOL_BASEREG (sym
);
1120 section
= SYMBOL_BFD_SECTION (sym
);
1122 switch (SYMBOL_CLASS (sym
))
1125 case LOC_CONST_BYTES
:
1126 printf_filtered ("constant");
1130 printf_filtered ("a label at address ");
1131 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1133 if (section_is_overlay (section
))
1135 load_addr
= overlay_unmapped_address (load_addr
, section
);
1136 printf_filtered (",\n -- loaded at ");
1137 print_address_numeric (load_addr
, 1, gdb_stdout
);
1138 printf_filtered (" in overlay section %s", section
->name
);
1143 case LOC_COMPUTED_ARG
:
1144 /* FIXME: cagney/2004-01-26: It should be possible to
1145 unconditionally call the SYMBOL_OPS method when available.
1146 Unfortunately DWARF 2 stores the frame-base (instead of the
1147 function) location in a function's symbol. Oops! For the
1148 moment enable this when/where applicable. */
1149 SYMBOL_OPS (sym
)->describe_location (sym
, gdb_stdout
);
1153 printf_filtered ("a variable in register %s", REGISTER_NAME (val
));
1157 printf_filtered ("static storage at address ");
1158 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1160 if (section_is_overlay (section
))
1162 load_addr
= overlay_unmapped_address (load_addr
, section
);
1163 printf_filtered (",\n -- loaded at ");
1164 print_address_numeric (load_addr
, 1, gdb_stdout
);
1165 printf_filtered (" in overlay section %s", section
->name
);
1170 printf_filtered ("external global (indirect addressing), at address *(");
1171 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1173 printf_filtered (")");
1174 if (section_is_overlay (section
))
1176 load_addr
= overlay_unmapped_address (load_addr
, section
);
1177 printf_filtered (",\n -- loaded at ");
1178 print_address_numeric (load_addr
, 1, gdb_stdout
);
1179 printf_filtered (" in overlay section %s", section
->name
);
1184 printf_filtered ("an argument in register %s", REGISTER_NAME (val
));
1187 case LOC_REGPARM_ADDR
:
1188 printf_filtered ("address of an argument in register %s", REGISTER_NAME (val
));
1192 printf_filtered ("an argument at offset %ld", val
);
1196 printf_filtered ("an argument at frame offset %ld", val
);
1200 printf_filtered ("a local variable at frame offset %ld", val
);
1204 printf_filtered ("a reference argument at offset %ld", val
);
1208 printf_filtered ("a variable at offset %ld from register %s",
1209 val
, REGISTER_NAME (basereg
));
1212 case LOC_BASEREG_ARG
:
1213 printf_filtered ("an argument at offset %ld from register %s",
1214 val
, REGISTER_NAME (basereg
));
1218 printf_filtered ("a typedef");
1222 printf_filtered ("a function at address ");
1223 print_address_numeric (load_addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)),
1225 if (section_is_overlay (section
))
1227 load_addr
= overlay_unmapped_address (load_addr
, section
);
1228 printf_filtered (",\n -- loaded at ");
1229 print_address_numeric (load_addr
, 1, gdb_stdout
);
1230 printf_filtered (" in overlay section %s", section
->name
);
1234 case LOC_UNRESOLVED
:
1236 struct minimal_symbol
*msym
;
1238 msym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym
), NULL
, NULL
);
1240 printf_filtered ("unresolved");
1243 section
= SYMBOL_BFD_SECTION (msym
);
1244 printf_filtered ("static storage at address ");
1245 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (msym
),
1247 if (section_is_overlay (section
))
1249 load_addr
= overlay_unmapped_address (load_addr
, section
);
1250 printf_filtered (",\n -- loaded at ");
1251 print_address_numeric (load_addr
, 1, gdb_stdout
);
1252 printf_filtered (" in overlay section %s", section
->name
);
1258 case LOC_HP_THREAD_LOCAL_STATIC
:
1260 "a thread-local variable at offset %ld from the thread base register %s",
1261 val
, REGISTER_NAME (basereg
));
1264 case LOC_OPTIMIZED_OUT
:
1265 printf_filtered ("optimized out");
1269 printf_filtered ("of unknown (botched) type");
1272 printf_filtered (".\n");
1276 x_command (char *exp
, int from_tty
)
1278 struct expression
*expr
;
1279 struct format_data fmt
;
1280 struct cleanup
*old_chain
;
1283 fmt
.format
= last_format
;
1284 fmt
.size
= last_size
;
1287 if (exp
&& *exp
== '/')
1290 fmt
= decode_format (&exp
, last_format
, last_size
);
1293 /* If we have an expression, evaluate it and use it as the address. */
1295 if (exp
!= 0 && *exp
!= 0)
1297 expr
= parse_expression (exp
);
1298 /* Cause expression not to be there any more
1299 if this command is repeated with Newline.
1300 But don't clobber a user-defined command's definition. */
1303 old_chain
= make_cleanup (free_current_contents
, &expr
);
1304 val
= evaluate_expression (expr
);
1305 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_REF
)
1306 val
= value_ind (val
);
1307 /* In rvalue contexts, such as this, functions are coerced into
1308 pointers to functions. This makes "x/i main" work. */
1309 if (/* last_format == 'i' && */
1310 TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FUNC
1311 && VALUE_LVAL (val
) == lval_memory
)
1312 next_address
= VALUE_ADDRESS (val
);
1314 next_address
= value_as_address (val
);
1315 if (VALUE_BFD_SECTION (val
))
1316 next_section
= VALUE_BFD_SECTION (val
);
1317 do_cleanups (old_chain
);
1320 do_examine (fmt
, next_address
, next_section
);
1322 /* If the examine succeeds, we remember its size and format for next time. */
1323 last_size
= fmt
.size
;
1324 last_format
= fmt
.format
;
1326 /* Set a couple of internal variables if appropriate. */
1327 if (last_examine_value
)
1329 /* Make last address examined available to the user as $_. Use
1330 the correct pointer type. */
1331 struct type
*pointer_type
1332 = lookup_pointer_type (VALUE_TYPE (last_examine_value
));
1333 set_internalvar (lookup_internalvar ("_"),
1334 value_from_pointer (pointer_type
,
1335 last_examine_address
));
1337 /* Make contents of last address examined available to the user as $__. */
1338 /* If the last value has not been fetched from memory then don't
1339 fetch it now - instead mark it by voiding the $__ variable. */
1340 if (VALUE_LAZY (last_examine_value
))
1341 set_internalvar (lookup_internalvar ("__"),
1342 allocate_value (builtin_type_void
));
1344 set_internalvar (lookup_internalvar ("__"), last_examine_value
);
1349 /* Add an expression to the auto-display chain.
1350 Specify the expression. */
1353 display_command (char *exp
, int from_tty
)
1355 struct format_data fmt
;
1356 struct expression
*expr
;
1357 struct display
*new;
1361 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1363 if (tui_active
&& *exp
== '$')
1364 display_it
= (tui_set_layout_for_display_command (exp
) == TUI_FAILURE
);
1378 fmt
= decode_format (&exp
, 0, 0);
1379 if (fmt
.size
&& fmt
.format
== 0)
1381 if (fmt
.format
== 'i' || fmt
.format
== 's')
1391 innermost_block
= 0;
1392 expr
= parse_expression (exp
);
1394 new = (struct display
*) xmalloc (sizeof (struct display
));
1397 new->block
= innermost_block
;
1398 new->next
= display_chain
;
1399 new->number
= ++display_number
;
1402 display_chain
= new;
1404 if (from_tty
&& target_has_execution
)
1405 do_one_display (new);
1412 free_display (struct display
*d
)
1418 /* Clear out the display_chain.
1419 Done when new symtabs are loaded, since this invalidates
1420 the types stored in many expressions. */
1423 clear_displays (void)
1427 while ((d
= display_chain
) != NULL
)
1430 display_chain
= d
->next
;
1435 /* Delete the auto-display number NUM. */
1438 delete_display (int num
)
1440 struct display
*d1
, *d
;
1443 error ("No display number %d.", num
);
1445 if (display_chain
->number
== num
)
1448 display_chain
= d1
->next
;
1452 for (d
= display_chain
;; d
= d
->next
)
1455 error ("No display number %d.", num
);
1456 if (d
->next
->number
== num
)
1466 /* Delete some values from the auto-display chain.
1467 Specify the element numbers. */
1470 undisplay_command (char *args
, int from_tty
)
1478 if (query ("Delete all auto-display expressions? "))
1487 while (*p1
>= '0' && *p1
<= '9')
1489 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1490 error ("Arguments must be display numbers.");
1494 delete_display (num
);
1497 while (*p
== ' ' || *p
== '\t')
1503 /* Display a single auto-display.
1504 Do nothing if the display cannot be printed in the current context,
1505 or if the display is disabled. */
1508 do_one_display (struct display
*d
)
1510 int within_current_scope
;
1512 if (d
->enabled_p
== 0)
1516 within_current_scope
= contained_in (get_selected_block (0), d
->block
);
1518 within_current_scope
= 1;
1519 if (!within_current_scope
)
1522 current_display_number
= d
->number
;
1524 annotate_display_begin ();
1525 printf_filtered ("%d", d
->number
);
1526 annotate_display_number_end ();
1527 printf_filtered (": ");
1533 annotate_display_format ();
1535 printf_filtered ("x/");
1536 if (d
->format
.count
!= 1)
1537 printf_filtered ("%d", d
->format
.count
);
1538 printf_filtered ("%c", d
->format
.format
);
1539 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1540 printf_filtered ("%c", d
->format
.size
);
1541 printf_filtered (" ");
1543 annotate_display_expression ();
1545 print_expression (d
->exp
, gdb_stdout
);
1546 annotate_display_expression_end ();
1548 if (d
->format
.count
!= 1)
1549 printf_filtered ("\n");
1551 printf_filtered (" ");
1553 val
= evaluate_expression (d
->exp
);
1554 addr
= value_as_address (val
);
1555 if (d
->format
.format
== 'i')
1556 addr
= ADDR_BITS_REMOVE (addr
);
1558 annotate_display_value ();
1560 do_examine (d
->format
, addr
, VALUE_BFD_SECTION (val
));
1564 annotate_display_format ();
1566 if (d
->format
.format
)
1567 printf_filtered ("/%c ", d
->format
.format
);
1569 annotate_display_expression ();
1571 print_expression (d
->exp
, gdb_stdout
);
1572 annotate_display_expression_end ();
1574 printf_filtered (" = ");
1576 annotate_display_expression ();
1578 print_formatted (evaluate_expression (d
->exp
),
1579 d
->format
.format
, d
->format
.size
, gdb_stdout
);
1580 printf_filtered ("\n");
1583 annotate_display_end ();
1585 gdb_flush (gdb_stdout
);
1586 current_display_number
= -1;
1589 /* Display all of the values on the auto-display chain which can be
1590 evaluated in the current scope. */
1597 for (d
= display_chain
; d
; d
= d
->next
)
1601 /* Delete the auto-display which we were in the process of displaying.
1602 This is done when there is an error or a signal. */
1605 disable_display (int num
)
1609 for (d
= display_chain
; d
; d
= d
->next
)
1610 if (d
->number
== num
)
1615 printf_unfiltered ("No display number %d.\n", num
);
1619 disable_current_display (void)
1621 if (current_display_number
>= 0)
1623 disable_display (current_display_number
);
1624 fprintf_unfiltered (gdb_stderr
, "Disabling display %d to avoid infinite recursion.\n",
1625 current_display_number
);
1627 current_display_number
= -1;
1631 display_info (char *ignore
, int from_tty
)
1636 printf_unfiltered ("There are no auto-display expressions now.\n");
1638 printf_filtered ("Auto-display expressions now in effect:\n\
1639 Num Enb Expression\n");
1641 for (d
= display_chain
; d
; d
= d
->next
)
1643 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
1645 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
1647 else if (d
->format
.format
)
1648 printf_filtered ("/%c ", d
->format
.format
);
1649 print_expression (d
->exp
, gdb_stdout
);
1650 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
))
1651 printf_filtered (" (cannot be evaluated in the current context)");
1652 printf_filtered ("\n");
1653 gdb_flush (gdb_stdout
);
1658 enable_display (char *args
, int from_tty
)
1667 for (d
= display_chain
; d
; d
= d
->next
)
1674 while (*p1
>= '0' && *p1
<= '9')
1676 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1677 error ("Arguments must be display numbers.");
1681 for (d
= display_chain
; d
; d
= d
->next
)
1682 if (d
->number
== num
)
1687 printf_unfiltered ("No display number %d.\n", num
);
1690 while (*p
== ' ' || *p
== '\t')
1696 disable_display_command (char *args
, int from_tty
)
1704 for (d
= display_chain
; d
; d
= d
->next
)
1711 while (*p1
>= '0' && *p1
<= '9')
1713 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1714 error ("Arguments must be display numbers.");
1716 disable_display (atoi (p
));
1719 while (*p
== ' ' || *p
== '\t')
1725 /* Print the value in stack frame FRAME of a variable
1726 specified by a struct symbol. */
1729 print_variable_value (struct symbol
*var
, struct frame_info
*frame
,
1730 struct ui_file
*stream
)
1732 struct value
*val
= read_var_value (var
, frame
);
1734 value_print (val
, stream
, 0, Val_pretty_default
);
1738 printf_command (char *arg
, int from_tty
)
1742 char *string
= NULL
;
1743 struct value
**val_args
;
1745 char *current_substring
;
1747 int allocated_args
= 20;
1748 struct cleanup
*old_cleanups
;
1750 val_args
= (struct value
**) xmalloc (allocated_args
1751 * sizeof (struct value
*));
1752 old_cleanups
= make_cleanup (free_current_contents
, &val_args
);
1755 error_no_arg ("format-control string and values to print");
1757 /* Skip white space before format string */
1758 while (*s
== ' ' || *s
== '\t')
1761 /* A format string should follow, enveloped in double quotes */
1763 error ("Bad format string, missing '\"'.");
1765 /* Parse the format-control string and copy it into the string STRING,
1766 processing some kinds of escape sequence. */
1768 f
= string
= (char *) alloca (strlen (s
) + 1);
1776 error ("Bad format string, non-terminated '\"'.");
1809 /* ??? TODO: handle other escape sequences */
1810 error ("Unrecognized escape character \\%c in format string.",
1820 /* Skip over " and following space and comma. */
1823 while (*s
== ' ' || *s
== '\t')
1826 if (*s
!= ',' && *s
!= 0)
1827 error ("Invalid argument syntax");
1831 while (*s
== ' ' || *s
== '\t')
1834 /* Need extra space for the '\0's. Doubling the size is sufficient. */
1835 substrings
= alloca (strlen (string
) * 2);
1836 current_substring
= substrings
;
1839 /* Now scan the string for %-specs and see what kinds of args they want.
1840 argclass[I] classifies the %-specs so we can give printf_filtered
1841 something of the right size. */
1845 no_arg
, int_arg
, string_arg
, double_arg
, long_long_arg
1847 enum argclass
*argclass
;
1848 enum argclass this_argclass
;
1854 argclass
= (enum argclass
*) alloca (strlen (s
) * sizeof *argclass
);
1862 while (strchr ("0123456789.hlL-+ #", *f
))
1864 if (*f
== 'l' || *f
== 'L')
1871 this_argclass
= string_arg
;
1877 this_argclass
= double_arg
;
1881 error ("`*' not supported for precision or width in printf");
1884 error ("Format specifier `n' not supported in printf");
1887 this_argclass
= no_arg
;
1892 this_argclass
= long_long_arg
;
1894 this_argclass
= int_arg
;
1898 if (this_argclass
!= no_arg
)
1900 strncpy (current_substring
, last_arg
, f
- last_arg
);
1901 current_substring
+= f
- last_arg
;
1902 *current_substring
++ = '\0';
1904 argclass
[nargs_wanted
++] = this_argclass
;
1908 /* Now, parse all arguments and evaluate them.
1909 Store the VALUEs in VAL_ARGS. */
1914 if (nargs
== allocated_args
)
1915 val_args
= (struct value
**) xrealloc ((char *) val_args
,
1916 (allocated_args
*= 2)
1917 * sizeof (struct value
*));
1919 val_args
[nargs
] = parse_to_comma_and_eval (&s1
);
1921 /* If format string wants a float, unchecked-convert the value to
1922 floating point of the same size */
1924 if (argclass
[nargs
] == double_arg
)
1926 struct type
*type
= VALUE_TYPE (val_args
[nargs
]);
1927 if (TYPE_LENGTH (type
) == sizeof (float))
1928 VALUE_TYPE (val_args
[nargs
]) = builtin_type_float
;
1929 if (TYPE_LENGTH (type
) == sizeof (double))
1930 VALUE_TYPE (val_args
[nargs
]) = builtin_type_double
;
1938 if (nargs
!= nargs_wanted
)
1939 error ("Wrong number of arguments for specified format-string");
1941 /* Now actually print them. */
1942 current_substring
= substrings
;
1943 for (i
= 0; i
< nargs
; i
++)
1945 switch (argclass
[i
])
1952 tem
= value_as_address (val_args
[i
]);
1954 /* This is a %s argument. Find the length of the string. */
1959 read_memory (tem
+ j
, &c
, 1);
1964 /* Copy the string contents into a string inside GDB. */
1965 str
= (char *) alloca (j
+ 1);
1967 read_memory (tem
, str
, j
);
1970 printf_filtered (current_substring
, str
);
1975 double val
= value_as_double (val_args
[i
]);
1976 printf_filtered (current_substring
, val
);
1980 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
1982 long long val
= value_as_long (val_args
[i
]);
1983 printf_filtered (current_substring
, val
);
1987 error ("long long not supported in printf");
1991 /* FIXME: there should be separate int_arg and long_arg. */
1992 long val
= value_as_long (val_args
[i
]);
1993 printf_filtered (current_substring
, val
);
1996 default: /* purecov: deadcode */
1997 error ("internal error in printf_command"); /* purecov: deadcode */
1999 /* Skip to the next substring. */
2000 current_substring
+= strlen (current_substring
) + 1;
2002 /* Print the portion of the format string after the last argument. */
2003 puts_filtered (last_arg
);
2005 do_cleanups (old_cleanups
);
2009 _initialize_printcmd (void)
2011 struct cmd_list_element
*c
;
2013 current_display_number
= -1;
2015 add_info ("address", address_info
,
2016 "Describe where symbol SYM is stored.");
2018 add_info ("symbol", sym_info
,
2019 "Describe what symbol is at location ADDR.\n\
2020 Only for symbols with fixed locations (global or static scope).");
2022 add_com ("x", class_vars
, x_command
,
2023 concat ("Examine memory: x/FMT ADDRESS.\n\
2024 ADDRESS is an expression for the memory address to examine.\n\
2025 FMT is a repeat count followed by a format letter and a size letter.\n\
2026 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2027 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n",
2028 "Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2029 The specified number of objects of the specified size are printed\n\
2030 according to the format.\n\n\
2031 Defaults for format and size letters are those previously used.\n\
2032 Default count is 1. Default address is following last thing printed\n\
2033 with this command or \"print\".", NULL
));
2036 add_com ("whereis", class_vars
, whereis_command
,
2037 "Print line number and file of definition of variable.");
2040 add_info ("display", display_info
,
2041 "Expressions to display when program stops, with code numbers.");
2043 add_cmd ("undisplay", class_vars
, undisplay_command
,
2044 "Cancel some expressions to be displayed when program stops.\n\
2045 Arguments are the code numbers of the expressions to stop displaying.\n\
2046 No argument means cancel all automatic-display expressions.\n\
2047 \"delete display\" has the same effect as this command.\n\
2048 Do \"info display\" to see current list of code numbers.",
2051 add_com ("display", class_vars
, display_command
,
2052 "Print value of expression EXP each time the program stops.\n\
2053 /FMT may be used before EXP as in the \"print\" command.\n\
2054 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2055 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2056 and examining is done as in the \"x\" command.\n\n\
2057 With no argument, display all currently requested auto-display expressions.\n\
2058 Use \"undisplay\" to cancel display requests previously made."
2061 add_cmd ("display", class_vars
, enable_display
,
2062 "Enable some expressions to be displayed when program stops.\n\
2063 Arguments are the code numbers of the expressions to resume displaying.\n\
2064 No argument means enable all automatic-display expressions.\n\
2065 Do \"info display\" to see current list of code numbers.", &enablelist
);
2067 add_cmd ("display", class_vars
, disable_display_command
,
2068 "Disable some expressions to be displayed when program stops.\n\
2069 Arguments are the code numbers of the expressions to stop displaying.\n\
2070 No argument means disable all automatic-display expressions.\n\
2071 Do \"info display\" to see current list of code numbers.", &disablelist
);
2073 add_cmd ("display", class_vars
, undisplay_command
,
2074 "Cancel some expressions to be displayed when program stops.\n\
2075 Arguments are the code numbers of the expressions to stop displaying.\n\
2076 No argument means cancel all automatic-display expressions.\n\
2077 Do \"info display\" to see current list of code numbers.", &deletelist
);
2079 add_com ("printf", class_vars
, printf_command
,
2080 "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2081 This is useful for formatted output in user-defined commands.");
2083 add_com ("output", class_vars
, output_command
,
2084 "Like \"print\" but don't put in value history and don't print newline.\n\
2085 This is useful in user-defined commands.");
2087 add_prefix_cmd ("set", class_vars
, set_command
,
2088 concat ("Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2089 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2090 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2091 with $), a register (a few standard names starting with $), or an actual\n\
2092 variable in the program being debugged. EXP is any valid expression.\n",
2093 "Use \"set variable\" for variables with names identical to set subcommands.\n\
2094 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2095 You can see these environment settings with the \"show\" command.", NULL
),
2096 &setlist
, "set ", 1, &cmdlist
);
2098 add_com ("assign", class_vars
, set_command
, concat ("Evaluate expression \
2099 EXP and assign result to variable VAR, using assignment\n\
2100 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2101 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2102 with $), a register (a few standard names starting with $), or an actual\n\
2103 variable in the program being debugged. EXP is any valid expression.\n",
2104 "Use \"set variable\" for variables with names identical to set subcommands.\n\
2105 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2106 You can see these environment settings with the \"show\" command.", NULL
));
2108 /* "call" is the same as "set", but handy for dbx users to call fns. */
2109 c
= add_com ("call", class_vars
, call_command
,
2110 "Call a function in the program.\n\
2111 The argument is the function name and arguments, in the notation of the\n\
2112 current working language. The result is printed and saved in the value\n\
2113 history, if it is not void.");
2114 set_cmd_completer (c
, location_completer
);
2116 add_cmd ("variable", class_vars
, set_command
,
2117 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2118 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2119 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2120 with $), a register (a few standard names starting with $), or an actual\n\
2121 variable in the program being debugged. EXP is any valid expression.\n\
2122 This may usually be abbreviated to simply \"set\".",
2125 c
= add_com ("print", class_vars
, print_command
,
2126 concat ("Print value of expression EXP.\n\
2127 Variables accessible are those of the lexical environment of the selected\n\
2128 stack frame, plus all those whose scope is global or an entire file.\n\
2130 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2131 $$NUM refers to NUM'th value back from the last one.\n\
2132 Names starting with $ refer to registers (with the values they would have\n",
2133 "if the program were to return to the stack frame now selected, restoring\n\
2134 all registers saved by frames farther in) or else to debugger\n\
2135 \"convenience\" variables (any such name not a known register).\n\
2136 Use assignment expressions to give values to convenience variables.\n",
2138 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2139 @ is a binary operator for treating consecutive data objects\n\
2140 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2141 element is FOO, whose second element is stored in the space following\n\
2142 where FOO is stored, etc. FOO must be an expression whose value\n\
2143 resides in memory.\n",
2145 EXP may be preceded with /FMT, where FMT is a format letter\n\
2146 but no count or size letter (see \"x\" command).", NULL
));
2147 set_cmd_completer (c
, location_completer
);
2148 add_com_alias ("p", "print", class_vars
, 1);
2150 c
= add_com ("inspect", class_vars
, inspect_command
,
2151 "Same as \"print\" command, except that if you are running in the epoch\n\
2152 environment, the value is printed in its own window.");
2153 set_cmd_completer (c
, location_completer
);
2156 add_set_cmd ("max-symbolic-offset", no_class
, var_uinteger
,
2157 (char *) &max_symbolic_offset
,
2158 "Set the largest offset that will be printed in <symbol+1234> form.",
2162 add_set_cmd ("symbol-filename", no_class
, var_boolean
,
2163 (char *) &print_symbol_filename
,
2164 "Set printing of source filename and line number with <symbol>.",
2168 /* For examine/instruction a single byte quantity is specified as
2169 the data. This avoids problems with value_at_lazy() requiring a
2170 valid data type (and rejecting VOID). */
2171 examine_i_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_i_type", NULL
);
2173 examine_b_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_b_type", NULL
);
2174 examine_h_type
= init_type (TYPE_CODE_INT
, 2, 0, "examine_h_type", NULL
);
2175 examine_w_type
= init_type (TYPE_CODE_INT
, 4, 0, "examine_w_type", NULL
);
2176 examine_g_type
= init_type (TYPE_CODE_INT
, 8, 0, "examine_g_type", NULL
);