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
);
353 if (len
> sizeof(LONGEST
) &&
354 (TYPE_CODE (type
) == TYPE_CODE_INT
355 || TYPE_CODE (type
) == TYPE_CODE_ENUM
))
360 print_octal_chars (stream
, valaddr
, len
);
364 print_decimal_chars (stream
, valaddr
, len
);
367 print_binary_chars (stream
, valaddr
, len
);
370 print_hex_chars (stream
, valaddr
, len
);
373 print_char_chars (stream
, valaddr
, len
);
381 val_long
= unpack_long (type
, valaddr
);
383 /* If the value is a pointer, and pointers and addresses are not the
384 same, then at this point, the value's length (in target bytes) is
385 TARGET_ADDR_BIT/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
386 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
387 len
= TARGET_ADDR_BIT
/ TARGET_CHAR_BIT
;
389 /* If we are printing it as unsigned, truncate it in case it is actually
390 a negative signed value (e.g. "print/u (short)-1" should print 65535
391 (if shorts are 16 bits) instead of 4294967295). */
394 if (len
< sizeof (LONGEST
))
395 val_long
&= ((LONGEST
) 1 << HOST_CHAR_BIT
* len
) - 1;
403 /* no size specified, like in print. Print varying # of digits. */
404 print_longest (stream
, 'x', 1, val_long
);
413 print_longest (stream
, size
, 1, val_long
);
416 error ("Undefined output size \"%c\".", size
);
421 print_longest (stream
, 'd', 1, val_long
);
425 print_longest (stream
, 'u', 0, val_long
);
430 print_longest (stream
, 'o', 1, val_long
);
432 fprintf_filtered (stream
, "0");
437 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
438 print_address (addr
, stream
);
443 value_print (value_from_longest (builtin_type_true_char
, val_long
),
444 stream
, 0, Val_pretty_default
);
448 if (len
== TYPE_LENGTH (builtin_type_float
))
449 type
= builtin_type_float
;
450 else if (len
== TYPE_LENGTH (builtin_type_double
))
451 type
= builtin_type_double
;
452 else if (len
== TYPE_LENGTH (builtin_type_long_double
))
453 type
= builtin_type_long_double
;
454 print_floating (valaddr
, type
, stream
);
458 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
461 /* Binary; 't' stands for "two". */
463 char bits
[8 * (sizeof val_long
) + 1];
464 char buf
[8 * (sizeof val_long
) + 32];
469 width
= 8 * (sizeof val_long
);
486 error ("Undefined output size \"%c\".", size
);
492 bits
[width
] = (val_long
& 1) ? '1' : '0';
497 while (*cp
&& *cp
== '0')
503 fputs_filtered (buf
, stream
);
508 error ("Undefined output format \"%c\".", format
);
512 /* Specify default address for `x' command.
513 `info lines' uses this. */
516 set_next_address (CORE_ADDR addr
)
520 /* Make address available to the user as $_. */
521 set_internalvar (lookup_internalvar ("_"),
522 value_from_pointer (lookup_pointer_type (builtin_type_void
),
526 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
527 after LEADIN. Print nothing if no symbolic name is found nearby.
528 Optionally also print source file and line number, if available.
529 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
530 or to interpret it as a possible C++ name and convert it back to source
531 form. However note that DO_DEMANGLE can be overridden by the specific
532 settings of the demangle and asm_demangle variables. */
535 print_address_symbolic (CORE_ADDR addr
, struct ui_file
*stream
, int do_demangle
,
539 char *filename
= NULL
;
544 /* throw away both name and filename */
545 struct cleanup
*cleanup_chain
= make_cleanup (free_current_contents
, &name
);
546 make_cleanup (free_current_contents
, &filename
);
548 if (build_address_symbolic (addr
, do_demangle
, &name
, &offset
, &filename
, &line
, &unmapped
))
550 do_cleanups (cleanup_chain
);
554 fputs_filtered (leadin
, stream
);
556 fputs_filtered ("<*", stream
);
558 fputs_filtered ("<", stream
);
559 fputs_filtered (name
, stream
);
561 fprintf_filtered (stream
, "+%u", (unsigned int) offset
);
563 /* Append source filename and line number if desired. Give specific
564 line # of this addr, if we have it; else line # of the nearest symbol. */
565 if (print_symbol_filename
&& filename
!= NULL
)
568 fprintf_filtered (stream
, " at %s:%d", filename
, line
);
570 fprintf_filtered (stream
, " in %s", filename
);
573 fputs_filtered ("*>", stream
);
575 fputs_filtered (">", stream
);
577 do_cleanups (cleanup_chain
);
580 /* Given an address ADDR return all the elements needed to print the
581 address in a symbolic form. NAME can be mangled or not depending
582 on DO_DEMANGLE (and also on the asm_demangle global variable,
583 manipulated via ''set print asm-demangle''). Return 0 in case of
584 success, when all the info in the OUT paramters is valid. Return 1
587 build_address_symbolic (CORE_ADDR addr
, /* IN */
588 int do_demangle
, /* IN */
589 char **name
, /* OUT */
590 int *offset
, /* OUT */
591 char **filename
, /* OUT */
593 int *unmapped
) /* OUT */
595 struct minimal_symbol
*msymbol
;
596 struct symbol
*symbol
;
597 struct symtab
*symtab
= 0;
598 CORE_ADDR name_location
= 0;
599 asection
*section
= 0;
600 char *name_temp
= "";
602 /* Let's say it is unmapped. */
605 /* Determine if the address is in an overlay, and whether it is
607 if (overlay_debugging
)
609 section
= find_pc_overlay (addr
);
610 if (pc_in_unmapped_range (addr
, section
))
613 addr
= overlay_mapped_address (addr
, section
);
617 /* First try to find the address in the symbol table, then
618 in the minsyms. Take the closest one. */
620 /* This is defective in the sense that it only finds text symbols. So
621 really this is kind of pointless--we should make sure that the
622 minimal symbols have everything we need (by changing that we could
623 save some memory, but for many debug format--ELF/DWARF or
624 anything/stabs--it would be inconvenient to eliminate those minimal
626 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
627 symbol
= find_pc_sect_function (addr
, section
);
631 name_location
= BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
));
632 if (do_demangle
|| asm_demangle
)
633 name_temp
= SYMBOL_PRINT_NAME (symbol
);
635 name_temp
= DEPRECATED_SYMBOL_NAME (symbol
);
640 if (SYMBOL_VALUE_ADDRESS (msymbol
) > name_location
|| symbol
== NULL
)
642 /* The msymbol is closer to the address than the symbol;
643 use the msymbol instead. */
646 name_location
= SYMBOL_VALUE_ADDRESS (msymbol
);
647 if (do_demangle
|| asm_demangle
)
648 name_temp
= SYMBOL_PRINT_NAME (msymbol
);
650 name_temp
= DEPRECATED_SYMBOL_NAME (msymbol
);
653 if (symbol
== NULL
&& msymbol
== NULL
)
656 /* If the nearest symbol is too far away, don't print anything symbolic. */
658 /* For when CORE_ADDR is larger than unsigned int, we do math in
659 CORE_ADDR. But when we detect unsigned wraparound in the
660 CORE_ADDR math, we ignore this test and print the offset,
661 because addr+max_symbolic_offset has wrapped through the end
662 of the address space back to the beginning, giving bogus comparison. */
663 if (addr
> name_location
+ max_symbolic_offset
664 && name_location
+ max_symbolic_offset
> name_location
)
667 *offset
= addr
- name_location
;
669 *name
= xstrdup (name_temp
);
671 if (print_symbol_filename
)
673 struct symtab_and_line sal
;
675 sal
= find_pc_sect_line (addr
, section
, 0);
679 *filename
= xstrdup (sal
.symtab
->filename
);
682 else if (symtab
&& symbol
&& symbol
->line
)
684 *filename
= xstrdup (symtab
->filename
);
685 *line
= symbol
->line
;
689 *filename
= xstrdup (symtab
->filename
);
696 /* Print address ADDR on STREAM. USE_LOCAL means the same thing as for
699 print_address_numeric (CORE_ADDR addr
, int use_local
, struct ui_file
*stream
)
701 /* Truncate address to the size of a target address, avoiding shifts
702 larger or equal than the width of a CORE_ADDR. The local
703 variable ADDR_BIT stops the compiler reporting a shift overflow
704 when it won't occur. */
705 /* NOTE: This assumes that the significant address information is
706 kept in the least significant bits of ADDR - the upper bits were
707 either zero or sign extended. Should ADDRESS_TO_POINTER() or
708 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
710 int addr_bit
= TARGET_ADDR_BIT
;
712 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
713 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
714 print_longest (stream
, 'x', use_local
, (ULONGEST
) addr
);
717 /* Print address ADDR symbolically on STREAM.
718 First print it as a number. Then perhaps print
719 <SYMBOL + OFFSET> after the number. */
722 print_address (CORE_ADDR addr
, struct ui_file
*stream
)
724 print_address_numeric (addr
, 1, stream
);
725 print_address_symbolic (addr
, stream
, asm_demangle
, " ");
728 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
729 controls whether to print the symbolic name "raw" or demangled.
730 Global setting "addressprint" controls whether to print hex address
734 print_address_demangle (CORE_ADDR addr
, struct ui_file
*stream
, int do_demangle
)
738 fprintf_filtered (stream
, "0");
740 else if (addressprint
)
742 print_address_numeric (addr
, 1, stream
);
743 print_address_symbolic (addr
, stream
, do_demangle
, " ");
747 print_address_symbolic (addr
, stream
, do_demangle
, "");
752 /* These are the types that $__ will get after an examine command of one
755 static struct type
*examine_i_type
;
757 static struct type
*examine_b_type
;
758 static struct type
*examine_h_type
;
759 static struct type
*examine_w_type
;
760 static struct type
*examine_g_type
;
762 /* Examine data at address ADDR in format FMT.
763 Fetch it from memory and print on gdb_stdout. */
766 do_examine (struct format_data fmt
, CORE_ADDR addr
, asection
*sect
)
771 struct type
*val_type
= NULL
;
781 /* String or instruction format implies fetch single bytes
782 regardless of the specified size. */
783 if (format
== 's' || format
== 'i')
787 val_type
= examine_i_type
;
788 else if (size
== 'b')
789 val_type
= examine_b_type
;
790 else if (size
== 'h')
791 val_type
= examine_h_type
;
792 else if (size
== 'w')
793 val_type
= examine_w_type
;
794 else if (size
== 'g')
795 val_type
= examine_g_type
;
802 if (format
== 's' || format
== 'i')
805 /* Print as many objects as specified in COUNT, at most maxelts per line,
806 with the address of the next one at the start of each line. */
811 print_address (next_address
, gdb_stdout
);
812 printf_filtered (":");
817 printf_filtered ("\t");
818 /* Note that print_formatted sets next_address for the next
820 last_examine_address
= next_address
;
822 if (last_examine_value
)
823 value_free (last_examine_value
);
825 /* The value to be displayed is not fetched greedily.
826 Instead, to avoid the posibility of a fetched value not
827 being used, its retreval is delayed until the print code
828 uses it. When examining an instruction stream, the
829 disassembler will perform its own memory fetch using just
830 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
831 the disassembler be modified so that LAST_EXAMINE_VALUE
832 is left with the byte sequence from the last complete
833 instruction fetched from memory? */
834 last_examine_value
= value_at_lazy (val_type
, next_address
, sect
);
836 if (last_examine_value
)
837 release_value (last_examine_value
);
839 print_formatted (last_examine_value
, format
, size
, gdb_stdout
);
841 printf_filtered ("\n");
842 gdb_flush (gdb_stdout
);
847 validate_format (struct format_data fmt
, char *cmdname
)
850 error ("Size letters are meaningless in \"%s\" command.", cmdname
);
852 error ("Item count other than 1 is meaningless in \"%s\" command.",
854 if (fmt
.format
== 'i' || fmt
.format
== 's')
855 error ("Format letter \"%c\" is meaningless in \"%s\" command.",
856 fmt
.format
, cmdname
);
859 /* Evaluate string EXP as an expression in the current language and
860 print the resulting value. EXP may contain a format specifier as the
861 first argument ("/x myvar" for example, to print myvar in hex).
865 print_command_1 (char *exp
, int inspect
, int voidprint
)
867 struct expression
*expr
;
868 struct cleanup
*old_chain
= 0;
871 struct format_data fmt
;
874 /* Pass inspect flag to the rest of the print routines in a global (sigh). */
875 inspect_it
= inspect
;
877 if (exp
&& *exp
== '/')
880 fmt
= decode_format (&exp
, last_format
, 0);
881 validate_format (fmt
, "print");
882 last_format
= format
= fmt
.format
;
894 expr
= parse_expression (exp
);
895 old_chain
= make_cleanup (free_current_contents
, &expr
);
897 val
= evaluate_expression (expr
);
900 val
= access_value_history (0);
902 if (voidprint
|| (val
&& VALUE_TYPE (val
) &&
903 TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_VOID
))
905 int histindex
= record_latest_value (val
);
908 annotate_value_history_begin (histindex
, VALUE_TYPE (val
));
910 annotate_value_begin (VALUE_TYPE (val
));
913 printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"", exp
, histindex
);
914 else if (histindex
>= 0)
915 printf_filtered ("$%d = ", histindex
);
918 annotate_value_history_value ();
920 print_formatted (val
, format
, fmt
.size
, gdb_stdout
);
921 printf_filtered ("\n");
924 annotate_value_history_end ();
926 annotate_value_end ();
929 printf_unfiltered ("\") )\030");
933 do_cleanups (old_chain
);
934 inspect_it
= 0; /* Reset print routines to normal */
938 print_command (char *exp
, int from_tty
)
940 print_command_1 (exp
, 0, 1);
943 /* Same as print, except in epoch, it gets its own window */
945 inspect_command (char *exp
, int from_tty
)
947 extern int epoch_interface
;
949 print_command_1 (exp
, epoch_interface
, 1);
952 /* Same as print, except it doesn't print void results. */
954 call_command (char *exp
, int from_tty
)
956 print_command_1 (exp
, 0, 0);
960 output_command (char *exp
, int from_tty
)
962 struct expression
*expr
;
963 struct cleanup
*old_chain
;
966 struct format_data fmt
;
968 if (exp
&& *exp
== '/')
971 fmt
= decode_format (&exp
, 0, 0);
972 validate_format (fmt
, "output");
976 expr
= parse_expression (exp
);
977 old_chain
= make_cleanup (free_current_contents
, &expr
);
979 val
= evaluate_expression (expr
);
981 annotate_value_begin (VALUE_TYPE (val
));
983 print_formatted (val
, format
, fmt
.size
, gdb_stdout
);
985 annotate_value_end ();
988 gdb_flush (gdb_stdout
);
990 do_cleanups (old_chain
);
994 set_command (char *exp
, int from_tty
)
996 struct expression
*expr
= parse_expression (exp
);
997 struct cleanup
*old_chain
=
998 make_cleanup (free_current_contents
, &expr
);
999 evaluate_expression (expr
);
1000 do_cleanups (old_chain
);
1004 sym_info (char *arg
, int from_tty
)
1006 struct minimal_symbol
*msymbol
;
1007 struct objfile
*objfile
;
1008 struct obj_section
*osect
;
1010 CORE_ADDR addr
, sect_addr
;
1012 unsigned int offset
;
1015 error_no_arg ("address");
1017 addr
= parse_and_eval_address (arg
);
1018 ALL_OBJSECTIONS (objfile
, osect
)
1020 sect
= osect
->the_bfd_section
;
1021 sect_addr
= overlay_mapped_address (addr
, sect
);
1023 if (osect
->addr
<= sect_addr
&& sect_addr
< osect
->endaddr
&&
1024 (msymbol
= lookup_minimal_symbol_by_pc_section (sect_addr
, sect
)))
1027 offset
= sect_addr
- SYMBOL_VALUE_ADDRESS (msymbol
);
1029 printf_filtered ("%s + %u in ",
1030 SYMBOL_PRINT_NAME (msymbol
), offset
);
1032 printf_filtered ("%s in ",
1033 SYMBOL_PRINT_NAME (msymbol
));
1034 if (pc_in_unmapped_range (addr
, sect
))
1035 printf_filtered ("load address range of ");
1036 if (section_is_overlay (sect
))
1037 printf_filtered ("%s overlay ",
1038 section_is_mapped (sect
) ? "mapped" : "unmapped");
1039 printf_filtered ("section %s", sect
->name
);
1040 printf_filtered ("\n");
1044 printf_filtered ("No symbol matches %s.\n", arg
);
1048 address_info (char *exp
, int from_tty
)
1051 struct minimal_symbol
*msymbol
;
1055 CORE_ADDR load_addr
;
1056 int is_a_field_of_this
; /* C++: lookup_symbol sets this to nonzero
1057 if exp is a field of `this'. */
1060 error ("Argument required.");
1062 sym
= lookup_symbol (exp
, get_selected_block (0), VAR_DOMAIN
,
1063 &is_a_field_of_this
, (struct symtab
**) NULL
);
1066 if (is_a_field_of_this
)
1068 printf_filtered ("Symbol \"");
1069 fprintf_symbol_filtered (gdb_stdout
, exp
,
1070 current_language
->la_language
, DMGL_ANSI
);
1071 printf_filtered ("\" is a field of the local class variable ");
1072 if (current_language
->la_language
== language_objc
)
1073 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1075 printf_filtered ("`this'\n");
1079 msymbol
= lookup_minimal_symbol (exp
, NULL
, NULL
);
1081 if (msymbol
!= NULL
)
1083 load_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1085 printf_filtered ("Symbol \"");
1086 fprintf_symbol_filtered (gdb_stdout
, exp
,
1087 current_language
->la_language
, DMGL_ANSI
);
1088 printf_filtered ("\" is at ");
1089 print_address_numeric (load_addr
, 1, gdb_stdout
);
1090 printf_filtered (" in a file compiled without debugging");
1091 section
= SYMBOL_BFD_SECTION (msymbol
);
1092 if (section_is_overlay (section
))
1094 load_addr
= overlay_unmapped_address (load_addr
, section
);
1095 printf_filtered (",\n -- loaded at ");
1096 print_address_numeric (load_addr
, 1, gdb_stdout
);
1097 printf_filtered (" in overlay section %s", section
->name
);
1099 printf_filtered (".\n");
1102 error ("No symbol \"%s\" in current context.", exp
);
1106 printf_filtered ("Symbol \"");
1107 fprintf_symbol_filtered (gdb_stdout
, DEPRECATED_SYMBOL_NAME (sym
),
1108 current_language
->la_language
, DMGL_ANSI
);
1109 printf_filtered ("\" is ");
1110 val
= SYMBOL_VALUE (sym
);
1111 basereg
= SYMBOL_BASEREG (sym
);
1112 section
= SYMBOL_BFD_SECTION (sym
);
1114 switch (SYMBOL_CLASS (sym
))
1117 case LOC_CONST_BYTES
:
1118 printf_filtered ("constant");
1122 printf_filtered ("a label at address ");
1123 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1125 if (section_is_overlay (section
))
1127 load_addr
= overlay_unmapped_address (load_addr
, section
);
1128 printf_filtered (",\n -- loaded at ");
1129 print_address_numeric (load_addr
, 1, gdb_stdout
);
1130 printf_filtered (" in overlay section %s", section
->name
);
1135 case LOC_COMPUTED_ARG
:
1136 /* FIXME: cagney/2004-01-26: It should be possible to
1137 unconditionally call the SYMBOL_OPS method when available.
1138 Unfortunately DWARF 2 stores the frame-base (instead of the
1139 function) location in a function's symbol. Oops! For the
1140 moment enable this when/where applicable. */
1141 SYMBOL_OPS (sym
)->describe_location (sym
, gdb_stdout
);
1145 printf_filtered ("a variable in register %s", REGISTER_NAME (val
));
1149 printf_filtered ("static storage at address ");
1150 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1152 if (section_is_overlay (section
))
1154 load_addr
= overlay_unmapped_address (load_addr
, section
);
1155 printf_filtered (",\n -- loaded at ");
1156 print_address_numeric (load_addr
, 1, gdb_stdout
);
1157 printf_filtered (" in overlay section %s", section
->name
);
1162 printf_filtered ("external global (indirect addressing), at address *(");
1163 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1165 printf_filtered (")");
1166 if (section_is_overlay (section
))
1168 load_addr
= overlay_unmapped_address (load_addr
, section
);
1169 printf_filtered (",\n -- loaded at ");
1170 print_address_numeric (load_addr
, 1, gdb_stdout
);
1171 printf_filtered (" in overlay section %s", section
->name
);
1176 printf_filtered ("an argument in register %s", REGISTER_NAME (val
));
1179 case LOC_REGPARM_ADDR
:
1180 printf_filtered ("address of an argument in register %s", REGISTER_NAME (val
));
1184 printf_filtered ("an argument at offset %ld", val
);
1188 printf_filtered ("an argument at frame offset %ld", val
);
1192 printf_filtered ("a local variable at frame offset %ld", val
);
1196 printf_filtered ("a reference argument at offset %ld", val
);
1200 printf_filtered ("a variable at offset %ld from register %s",
1201 val
, REGISTER_NAME (basereg
));
1204 case LOC_BASEREG_ARG
:
1205 printf_filtered ("an argument at offset %ld from register %s",
1206 val
, REGISTER_NAME (basereg
));
1210 printf_filtered ("a typedef");
1214 printf_filtered ("a function at address ");
1215 print_address_numeric (load_addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)),
1217 if (section_is_overlay (section
))
1219 load_addr
= overlay_unmapped_address (load_addr
, section
);
1220 printf_filtered (",\n -- loaded at ");
1221 print_address_numeric (load_addr
, 1, gdb_stdout
);
1222 printf_filtered (" in overlay section %s", section
->name
);
1226 case LOC_UNRESOLVED
:
1228 struct minimal_symbol
*msym
;
1230 msym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym
), NULL
, NULL
);
1232 printf_filtered ("unresolved");
1235 section
= SYMBOL_BFD_SECTION (msym
);
1236 printf_filtered ("static storage at address ");
1237 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (msym
),
1239 if (section_is_overlay (section
))
1241 load_addr
= overlay_unmapped_address (load_addr
, section
);
1242 printf_filtered (",\n -- loaded at ");
1243 print_address_numeric (load_addr
, 1, gdb_stdout
);
1244 printf_filtered (" in overlay section %s", section
->name
);
1250 case LOC_HP_THREAD_LOCAL_STATIC
:
1252 "a thread-local variable at offset %ld from the thread base register %s",
1253 val
, REGISTER_NAME (basereg
));
1256 case LOC_OPTIMIZED_OUT
:
1257 printf_filtered ("optimized out");
1261 printf_filtered ("of unknown (botched) type");
1264 printf_filtered (".\n");
1268 x_command (char *exp
, int from_tty
)
1270 struct expression
*expr
;
1271 struct format_data fmt
;
1272 struct cleanup
*old_chain
;
1275 fmt
.format
= last_format
;
1276 fmt
.size
= last_size
;
1279 if (exp
&& *exp
== '/')
1282 fmt
= decode_format (&exp
, last_format
, last_size
);
1285 /* If we have an expression, evaluate it and use it as the address. */
1287 if (exp
!= 0 && *exp
!= 0)
1289 expr
= parse_expression (exp
);
1290 /* Cause expression not to be there any more
1291 if this command is repeated with Newline.
1292 But don't clobber a user-defined command's definition. */
1295 old_chain
= make_cleanup (free_current_contents
, &expr
);
1296 val
= evaluate_expression (expr
);
1297 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_REF
)
1298 val
= value_ind (val
);
1299 /* In rvalue contexts, such as this, functions are coerced into
1300 pointers to functions. This makes "x/i main" work. */
1301 if (/* last_format == 'i' && */
1302 TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FUNC
1303 && VALUE_LVAL (val
) == lval_memory
)
1304 next_address
= VALUE_ADDRESS (val
);
1306 next_address
= value_as_address (val
);
1307 if (VALUE_BFD_SECTION (val
))
1308 next_section
= VALUE_BFD_SECTION (val
);
1309 do_cleanups (old_chain
);
1312 do_examine (fmt
, next_address
, next_section
);
1314 /* If the examine succeeds, we remember its size and format for next time. */
1315 last_size
= fmt
.size
;
1316 last_format
= fmt
.format
;
1318 /* Set a couple of internal variables if appropriate. */
1319 if (last_examine_value
)
1321 /* Make last address examined available to the user as $_. Use
1322 the correct pointer type. */
1323 struct type
*pointer_type
1324 = lookup_pointer_type (VALUE_TYPE (last_examine_value
));
1325 set_internalvar (lookup_internalvar ("_"),
1326 value_from_pointer (pointer_type
,
1327 last_examine_address
));
1329 /* Make contents of last address examined available to the user as $__. */
1330 /* If the last value has not been fetched from memory then don't
1331 fetch it now - instead mark it by voiding the $__ variable. */
1332 if (VALUE_LAZY (last_examine_value
))
1333 set_internalvar (lookup_internalvar ("__"),
1334 allocate_value (builtin_type_void
));
1336 set_internalvar (lookup_internalvar ("__"), last_examine_value
);
1341 /* Add an expression to the auto-display chain.
1342 Specify the expression. */
1345 display_command (char *exp
, int from_tty
)
1347 struct format_data fmt
;
1348 struct expression
*expr
;
1349 struct display
*new;
1353 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1355 if (tui_active
&& exp
!= NULL
&& *exp
== '$')
1356 display_it
= (tui_set_layout_for_display_command (exp
) == TUI_FAILURE
);
1370 fmt
= decode_format (&exp
, 0, 0);
1371 if (fmt
.size
&& fmt
.format
== 0)
1373 if (fmt
.format
== 'i' || fmt
.format
== 's')
1383 innermost_block
= 0;
1384 expr
= parse_expression (exp
);
1386 new = (struct display
*) xmalloc (sizeof (struct display
));
1389 new->block
= innermost_block
;
1390 new->next
= display_chain
;
1391 new->number
= ++display_number
;
1394 display_chain
= new;
1396 if (from_tty
&& target_has_execution
)
1397 do_one_display (new);
1404 free_display (struct display
*d
)
1410 /* Clear out the display_chain.
1411 Done when new symtabs are loaded, since this invalidates
1412 the types stored in many expressions. */
1415 clear_displays (void)
1419 while ((d
= display_chain
) != NULL
)
1422 display_chain
= d
->next
;
1427 /* Delete the auto-display number NUM. */
1430 delete_display (int num
)
1432 struct display
*d1
, *d
;
1435 error ("No display number %d.", num
);
1437 if (display_chain
->number
== num
)
1440 display_chain
= d1
->next
;
1444 for (d
= display_chain
;; d
= d
->next
)
1447 error ("No display number %d.", num
);
1448 if (d
->next
->number
== num
)
1458 /* Delete some values from the auto-display chain.
1459 Specify the element numbers. */
1462 undisplay_command (char *args
, int from_tty
)
1470 if (query ("Delete all auto-display expressions? "))
1479 while (*p1
>= '0' && *p1
<= '9')
1481 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1482 error ("Arguments must be display numbers.");
1486 delete_display (num
);
1489 while (*p
== ' ' || *p
== '\t')
1495 /* Display a single auto-display.
1496 Do nothing if the display cannot be printed in the current context,
1497 or if the display is disabled. */
1500 do_one_display (struct display
*d
)
1502 int within_current_scope
;
1504 if (d
->enabled_p
== 0)
1508 within_current_scope
= contained_in (get_selected_block (0), d
->block
);
1510 within_current_scope
= 1;
1511 if (!within_current_scope
)
1514 current_display_number
= d
->number
;
1516 annotate_display_begin ();
1517 printf_filtered ("%d", d
->number
);
1518 annotate_display_number_end ();
1519 printf_filtered (": ");
1525 annotate_display_format ();
1527 printf_filtered ("x/");
1528 if (d
->format
.count
!= 1)
1529 printf_filtered ("%d", d
->format
.count
);
1530 printf_filtered ("%c", d
->format
.format
);
1531 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1532 printf_filtered ("%c", d
->format
.size
);
1533 printf_filtered (" ");
1535 annotate_display_expression ();
1537 print_expression (d
->exp
, gdb_stdout
);
1538 annotate_display_expression_end ();
1540 if (d
->format
.count
!= 1)
1541 printf_filtered ("\n");
1543 printf_filtered (" ");
1545 val
= evaluate_expression (d
->exp
);
1546 addr
= value_as_address (val
);
1547 if (d
->format
.format
== 'i')
1548 addr
= ADDR_BITS_REMOVE (addr
);
1550 annotate_display_value ();
1552 do_examine (d
->format
, addr
, VALUE_BFD_SECTION (val
));
1556 annotate_display_format ();
1558 if (d
->format
.format
)
1559 printf_filtered ("/%c ", d
->format
.format
);
1561 annotate_display_expression ();
1563 print_expression (d
->exp
, gdb_stdout
);
1564 annotate_display_expression_end ();
1566 printf_filtered (" = ");
1568 annotate_display_expression ();
1570 print_formatted (evaluate_expression (d
->exp
),
1571 d
->format
.format
, d
->format
.size
, gdb_stdout
);
1572 printf_filtered ("\n");
1575 annotate_display_end ();
1577 gdb_flush (gdb_stdout
);
1578 current_display_number
= -1;
1581 /* Display all of the values on the auto-display chain which can be
1582 evaluated in the current scope. */
1589 for (d
= display_chain
; d
; d
= d
->next
)
1593 /* Delete the auto-display which we were in the process of displaying.
1594 This is done when there is an error or a signal. */
1597 disable_display (int num
)
1601 for (d
= display_chain
; d
; d
= d
->next
)
1602 if (d
->number
== num
)
1607 printf_unfiltered ("No display number %d.\n", num
);
1611 disable_current_display (void)
1613 if (current_display_number
>= 0)
1615 disable_display (current_display_number
);
1616 fprintf_unfiltered (gdb_stderr
, "Disabling display %d to avoid infinite recursion.\n",
1617 current_display_number
);
1619 current_display_number
= -1;
1623 display_info (char *ignore
, int from_tty
)
1628 printf_unfiltered ("There are no auto-display expressions now.\n");
1630 printf_filtered ("Auto-display expressions now in effect:\n\
1631 Num Enb Expression\n");
1633 for (d
= display_chain
; d
; d
= d
->next
)
1635 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
1637 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
1639 else if (d
->format
.format
)
1640 printf_filtered ("/%c ", d
->format
.format
);
1641 print_expression (d
->exp
, gdb_stdout
);
1642 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
))
1643 printf_filtered (" (cannot be evaluated in the current context)");
1644 printf_filtered ("\n");
1645 gdb_flush (gdb_stdout
);
1650 enable_display (char *args
, int from_tty
)
1659 for (d
= display_chain
; d
; d
= d
->next
)
1666 while (*p1
>= '0' && *p1
<= '9')
1668 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1669 error ("Arguments must be display numbers.");
1673 for (d
= display_chain
; d
; d
= d
->next
)
1674 if (d
->number
== num
)
1679 printf_unfiltered ("No display number %d.\n", num
);
1682 while (*p
== ' ' || *p
== '\t')
1688 disable_display_command (char *args
, int from_tty
)
1696 for (d
= display_chain
; d
; d
= d
->next
)
1703 while (*p1
>= '0' && *p1
<= '9')
1705 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1706 error ("Arguments must be display numbers.");
1708 disable_display (atoi (p
));
1711 while (*p
== ' ' || *p
== '\t')
1717 /* Print the value in stack frame FRAME of a variable
1718 specified by a struct symbol. */
1721 print_variable_value (struct symbol
*var
, struct frame_info
*frame
,
1722 struct ui_file
*stream
)
1724 struct value
*val
= read_var_value (var
, frame
);
1726 value_print (val
, stream
, 0, Val_pretty_default
);
1730 printf_command (char *arg
, int from_tty
)
1734 char *string
= NULL
;
1735 struct value
**val_args
;
1737 char *current_substring
;
1739 int allocated_args
= 20;
1740 struct cleanup
*old_cleanups
;
1742 val_args
= (struct value
**) xmalloc (allocated_args
1743 * sizeof (struct value
*));
1744 old_cleanups
= make_cleanup (free_current_contents
, &val_args
);
1747 error_no_arg ("format-control string and values to print");
1749 /* Skip white space before format string */
1750 while (*s
== ' ' || *s
== '\t')
1753 /* A format string should follow, enveloped in double quotes */
1755 error ("Bad format string, missing '\"'.");
1757 /* Parse the format-control string and copy it into the string STRING,
1758 processing some kinds of escape sequence. */
1760 f
= string
= (char *) alloca (strlen (s
) + 1);
1768 error ("Bad format string, non-terminated '\"'.");
1801 /* ??? TODO: handle other escape sequences */
1802 error ("Unrecognized escape character \\%c in format string.",
1812 /* Skip over " and following space and comma. */
1815 while (*s
== ' ' || *s
== '\t')
1818 if (*s
!= ',' && *s
!= 0)
1819 error ("Invalid argument syntax");
1823 while (*s
== ' ' || *s
== '\t')
1826 /* Need extra space for the '\0's. Doubling the size is sufficient. */
1827 substrings
= alloca (strlen (string
) * 2);
1828 current_substring
= substrings
;
1831 /* Now scan the string for %-specs and see what kinds of args they want.
1832 argclass[I] classifies the %-specs so we can give printf_filtered
1833 something of the right size. */
1837 no_arg
, int_arg
, string_arg
, double_arg
, long_long_arg
1839 enum argclass
*argclass
;
1840 enum argclass this_argclass
;
1846 argclass
= (enum argclass
*) alloca (strlen (s
) * sizeof *argclass
);
1854 while (strchr ("0123456789.hlL-+ #", *f
))
1856 if (*f
== 'l' || *f
== 'L')
1863 this_argclass
= string_arg
;
1869 this_argclass
= double_arg
;
1873 error ("`*' not supported for precision or width in printf");
1876 error ("Format specifier `n' not supported in printf");
1879 this_argclass
= no_arg
;
1884 this_argclass
= long_long_arg
;
1886 this_argclass
= int_arg
;
1890 if (this_argclass
!= no_arg
)
1892 strncpy (current_substring
, last_arg
, f
- last_arg
);
1893 current_substring
+= f
- last_arg
;
1894 *current_substring
++ = '\0';
1896 argclass
[nargs_wanted
++] = this_argclass
;
1900 /* Now, parse all arguments and evaluate them.
1901 Store the VALUEs in VAL_ARGS. */
1906 if (nargs
== allocated_args
)
1907 val_args
= (struct value
**) xrealloc ((char *) val_args
,
1908 (allocated_args
*= 2)
1909 * sizeof (struct value
*));
1911 val_args
[nargs
] = parse_to_comma_and_eval (&s1
);
1913 /* If format string wants a float, unchecked-convert the value to
1914 floating point of the same size */
1916 if (argclass
[nargs
] == double_arg
)
1918 struct type
*type
= VALUE_TYPE (val_args
[nargs
]);
1919 if (TYPE_LENGTH (type
) == sizeof (float))
1920 VALUE_TYPE (val_args
[nargs
]) = builtin_type_float
;
1921 if (TYPE_LENGTH (type
) == sizeof (double))
1922 VALUE_TYPE (val_args
[nargs
]) = builtin_type_double
;
1930 if (nargs
!= nargs_wanted
)
1931 error ("Wrong number of arguments for specified format-string");
1933 /* Now actually print them. */
1934 current_substring
= substrings
;
1935 for (i
= 0; i
< nargs
; i
++)
1937 switch (argclass
[i
])
1944 tem
= value_as_address (val_args
[i
]);
1946 /* This is a %s argument. Find the length of the string. */
1951 read_memory (tem
+ j
, &c
, 1);
1956 /* Copy the string contents into a string inside GDB. */
1957 str
= (char *) alloca (j
+ 1);
1959 read_memory (tem
, str
, j
);
1962 printf_filtered (current_substring
, str
);
1967 double val
= value_as_double (val_args
[i
]);
1968 printf_filtered (current_substring
, val
);
1972 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
1974 long long val
= value_as_long (val_args
[i
]);
1975 printf_filtered (current_substring
, val
);
1979 error ("long long not supported in printf");
1983 /* FIXME: there should be separate int_arg and long_arg. */
1984 long val
= value_as_long (val_args
[i
]);
1985 printf_filtered (current_substring
, val
);
1988 default: /* purecov: deadcode */
1989 error ("internal error in printf_command"); /* purecov: deadcode */
1991 /* Skip to the next substring. */
1992 current_substring
+= strlen (current_substring
) + 1;
1994 /* Print the portion of the format string after the last argument. */
1995 puts_filtered (last_arg
);
1997 do_cleanups (old_cleanups
);
2001 _initialize_printcmd (void)
2003 struct cmd_list_element
*c
;
2005 current_display_number
= -1;
2007 add_info ("address", address_info
,
2008 "Describe where symbol SYM is stored.");
2010 add_info ("symbol", sym_info
,
2011 "Describe what symbol is at location ADDR.\n\
2012 Only for symbols with fixed locations (global or static scope).");
2014 add_com ("x", class_vars
, x_command
,
2015 concat ("Examine memory: x/FMT ADDRESS.\n\
2016 ADDRESS is an expression for the memory address to examine.\n\
2017 FMT is a repeat count followed by a format letter and a size letter.\n\
2018 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2019 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n",
2020 "Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2021 The specified number of objects of the specified size are printed\n\
2022 according to the format.\n\n\
2023 Defaults for format and size letters are those previously used.\n\
2024 Default count is 1. Default address is following last thing printed\n\
2025 with this command or \"print\".", NULL
));
2028 add_com ("whereis", class_vars
, whereis_command
,
2029 "Print line number and file of definition of variable.");
2032 add_info ("display", display_info
,
2033 "Expressions to display when program stops, with code numbers.");
2035 add_cmd ("undisplay", class_vars
, undisplay_command
,
2036 "Cancel some expressions to be displayed when program stops.\n\
2037 Arguments are the code numbers of the expressions to stop displaying.\n\
2038 No argument means cancel all automatic-display expressions.\n\
2039 \"delete display\" has the same effect as this command.\n\
2040 Do \"info display\" to see current list of code numbers.",
2043 add_com ("display", class_vars
, display_command
,
2044 "Print value of expression EXP each time the program stops.\n\
2045 /FMT may be used before EXP as in the \"print\" command.\n\
2046 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2047 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2048 and examining is done as in the \"x\" command.\n\n\
2049 With no argument, display all currently requested auto-display expressions.\n\
2050 Use \"undisplay\" to cancel display requests previously made."
2053 add_cmd ("display", class_vars
, enable_display
,
2054 "Enable some expressions to be displayed when program stops.\n\
2055 Arguments are the code numbers of the expressions to resume displaying.\n\
2056 No argument means enable all automatic-display expressions.\n\
2057 Do \"info display\" to see current list of code numbers.", &enablelist
);
2059 add_cmd ("display", class_vars
, disable_display_command
,
2060 "Disable some expressions to be displayed when program stops.\n\
2061 Arguments are the code numbers of the expressions to stop displaying.\n\
2062 No argument means disable all automatic-display expressions.\n\
2063 Do \"info display\" to see current list of code numbers.", &disablelist
);
2065 add_cmd ("display", class_vars
, undisplay_command
,
2066 "Cancel some expressions to be displayed when program stops.\n\
2067 Arguments are the code numbers of the expressions to stop displaying.\n\
2068 No argument means cancel all automatic-display expressions.\n\
2069 Do \"info display\" to see current list of code numbers.", &deletelist
);
2071 add_com ("printf", class_vars
, printf_command
,
2072 "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2073 This is useful for formatted output in user-defined commands.");
2075 add_com ("output", class_vars
, output_command
,
2076 "Like \"print\" but don't put in value history and don't print newline.\n\
2077 This is useful in user-defined commands.");
2079 add_prefix_cmd ("set", class_vars
, set_command
,
2080 concat ("Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2081 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2082 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2083 with $), a register (a few standard names starting with $), or an actual\n\
2084 variable in the program being debugged. EXP is any valid expression.\n",
2085 "Use \"set variable\" for variables with names identical to set subcommands.\n\
2086 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2087 You can see these environment settings with the \"show\" command.", NULL
),
2088 &setlist
, "set ", 1, &cmdlist
);
2090 add_com ("assign", class_vars
, set_command
, concat ("Evaluate expression \
2091 EXP and assign result to variable VAR, using assignment\n\
2092 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2093 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2094 with $), a register (a few standard names starting with $), or an actual\n\
2095 variable in the program being debugged. EXP is any valid expression.\n",
2096 "Use \"set variable\" for variables with names identical to set subcommands.\n\
2097 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2098 You can see these environment settings with the \"show\" command.", NULL
));
2100 /* "call" is the same as "set", but handy for dbx users to call fns. */
2101 c
= add_com ("call", class_vars
, call_command
,
2102 "Call a function in the program.\n\
2103 The argument is the function name and arguments, in the notation of the\n\
2104 current working language. The result is printed and saved in the value\n\
2105 history, if it is not void.");
2106 set_cmd_completer (c
, location_completer
);
2108 add_cmd ("variable", class_vars
, set_command
,
2109 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2110 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2111 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2112 with $), a register (a few standard names starting with $), or an actual\n\
2113 variable in the program being debugged. EXP is any valid expression.\n\
2114 This may usually be abbreviated to simply \"set\".",
2117 c
= add_com ("print", class_vars
, print_command
,
2118 concat ("Print value of expression EXP.\n\
2119 Variables accessible are those of the lexical environment of the selected\n\
2120 stack frame, plus all those whose scope is global or an entire file.\n\
2122 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2123 $$NUM refers to NUM'th value back from the last one.\n\
2124 Names starting with $ refer to registers (with the values they would have\n",
2125 "if the program were to return to the stack frame now selected, restoring\n\
2126 all registers saved by frames farther in) or else to debugger\n\
2127 \"convenience\" variables (any such name not a known register).\n\
2128 Use assignment expressions to give values to convenience variables.\n",
2130 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2131 @ is a binary operator for treating consecutive data objects\n\
2132 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2133 element is FOO, whose second element is stored in the space following\n\
2134 where FOO is stored, etc. FOO must be an expression whose value\n\
2135 resides in memory.\n",
2137 EXP may be preceded with /FMT, where FMT is a format letter\n\
2138 but no count or size letter (see \"x\" command).", NULL
));
2139 set_cmd_completer (c
, location_completer
);
2140 add_com_alias ("p", "print", class_vars
, 1);
2142 c
= add_com ("inspect", class_vars
, inspect_command
,
2143 "Same as \"print\" command, except that if you are running in the epoch\n\
2144 environment, the value is printed in its own window.");
2145 set_cmd_completer (c
, location_completer
);
2147 deprecated_add_show_from_set
2148 (add_set_cmd ("max-symbolic-offset", no_class
, var_uinteger
,
2149 (char *) &max_symbolic_offset
,
2150 "Set the largest offset that will be printed in <symbol+1234> form.",
2153 deprecated_add_show_from_set
2154 (add_set_cmd ("symbol-filename", no_class
, var_boolean
,
2155 (char *) &print_symbol_filename
, "\
2156 Set printing of source filename and line number with <symbol>.",
2160 /* For examine/instruction a single byte quantity is specified as
2161 the data. This avoids problems with value_at_lazy() requiring a
2162 valid data type (and rejecting VOID). */
2163 examine_i_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_i_type", NULL
);
2165 examine_b_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_b_type", NULL
);
2166 examine_h_type
= init_type (TYPE_CODE_INT
, 2, 0, "examine_h_type", NULL
);
2167 examine_w_type
= init_type (TYPE_CODE_INT
, 4, 0, "examine_w_type", NULL
);
2168 examine_g_type
= init_type (TYPE_CODE_INT
, 8, 0, "examine_g_type", NULL
);