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"
46 extern int asm_demangle
; /* Whether to demangle syms in asm printouts */
47 extern int addressprint
; /* Whether to print hex addresses in HLL " */
56 /* Last specified output format. */
58 static char last_format
= 'x';
60 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
62 static char last_size
= 'w';
64 /* Default address to examine next. */
66 static CORE_ADDR next_address
;
68 /* Default section to examine next. */
70 static asection
*next_section
;
72 /* Last address examined. */
74 static CORE_ADDR last_examine_address
;
76 /* Contents of last address examined.
77 This is not valid past the end of the `x' command! */
79 static struct value
*last_examine_value
;
81 /* Largest offset between a symbolic value and an address, that will be
82 printed as `0x1234 <symbol+offset>'. */
84 static unsigned int max_symbolic_offset
= UINT_MAX
;
86 /* Append the source filename and linenumber of the symbol when
87 printing a symbolic value as `<symbol at filename:linenum>' if set. */
88 static int print_symbol_filename
= 0;
90 /* Number of auto-display expression currently being displayed.
91 So that we can disable it if we get an error or a signal within it.
92 -1 when not doing one. */
94 int current_display_number
;
96 /* Flag to low-level print routines that this value is being printed
97 in an epoch window. We'd like to pass this as a parameter, but
98 every routine would need to take it. Perhaps we can encapsulate
99 this in the I/O stream once we have GNU stdio. */
105 /* Chain link to next auto-display item. */
106 struct display
*next
;
107 /* Expression to be evaluated and displayed. */
108 struct expression
*exp
;
109 /* Item number of this auto-display item. */
111 /* Display format specified. */
112 struct format_data format
;
113 /* Innermost block required by this expression when evaluated */
115 /* Status of this display (enabled or disabled) */
119 /* Chain of expressions whose values should be displayed
120 automatically each time the program stops. */
122 static struct display
*display_chain
;
124 static int display_number
;
126 /* Prototypes for exported functions. */
128 void output_command (char *, int);
130 void _initialize_printcmd (void);
132 /* Prototypes for local functions. */
134 static void delete_display (int);
136 static void enable_display (char *, int);
138 static void disable_display_command (char *, int);
140 static void printf_command (char *, int);
142 static void print_frame_nameless_args (struct frame_info
*, long,
143 int, int, struct ui_file
*);
145 static void display_info (char *, int);
147 static void do_one_display (struct display
*);
149 static void undisplay_command (char *, int);
151 static void free_display (struct display
*);
153 static void display_command (char *, int);
155 void x_command (char *, int);
157 static void address_info (char *, int);
159 static void set_command (char *, int);
161 static void call_command (char *, int);
163 static void inspect_command (char *, int);
165 static void print_command (char *, int);
167 static void print_command_1 (char *, int, int);
169 static void validate_format (struct format_data
, char *);
171 static void do_examine (struct format_data
, CORE_ADDR addr
,
174 static void print_formatted (struct value
*, int, int, struct ui_file
*);
176 static struct format_data
decode_format (char **, int, int);
178 static int print_insn (CORE_ADDR
, struct ui_file
*);
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 register 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
, register 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 + 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 /* If format is 0, use the 'natural' format for
324 * that type of value. If the type is non-scalar,
325 * we have to use language rules to print it as
326 * a series of scalars.
328 value_print (val
, stream
, format
, Val_pretty_default
);
330 /* User specified format, so don't look to the
331 * the type to tell us what to do.
333 print_scalar_formatted (VALUE_CONTENTS (val
), type
,
334 format
, size
, stream
);
338 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
339 according to letters FORMAT and SIZE on STREAM.
340 FORMAT may not be zero. Formats s and i are not supported at this level.
342 This is how the elements of an array or structure are printed
346 print_scalar_formatted (void *valaddr
, struct type
*type
, int format
, int size
,
347 struct ui_file
*stream
)
350 unsigned int len
= TYPE_LENGTH (type
);
352 if (len
> sizeof (LONGEST
)
360 if (!TYPE_UNSIGNED (type
)
361 || !extract_long_unsigned_integer (valaddr
, len
, &val_long
))
363 /* We can't print it normally, but we can print it in hex.
364 Printing it in the wrong radix is more useful than saying
365 "use /x, you dummy". */
366 /* FIXME: we could also do octal or binary if that was the
368 /* FIXME: we should be using the size field to give us a
369 minimum field width to print. */
372 print_octal_chars (stream
, valaddr
, len
);
373 else if (format
== 'd')
374 print_decimal_chars (stream
, valaddr
, len
);
375 else if (format
== 't')
376 print_binary_chars (stream
, valaddr
, len
);
378 /* replace with call to print_hex_chars? Looks
379 like val_print_type_code_int is redoing
382 val_print_type_code_int (type
, valaddr
, stream
);
387 /* If we get here, extract_long_unsigned_integer set val_long. */
389 else if (format
!= 'f')
390 val_long
= unpack_long (type
, valaddr
);
392 /* If the value is a pointer, and pointers and addresses are not the
393 same, then at this point, the value's length (in target bytes) is
394 TARGET_ADDR_BIT/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
395 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
396 len
= TARGET_ADDR_BIT
/ TARGET_CHAR_BIT
;
398 /* If we are printing it as unsigned, truncate it in case it is actually
399 a negative signed value (e.g. "print/u (short)-1" should print 65535
400 (if shorts are 16 bits) instead of 4294967295). */
403 if (len
< sizeof (LONGEST
))
404 val_long
&= ((LONGEST
) 1 << HOST_CHAR_BIT
* len
) - 1;
412 /* no size specified, like in print. Print varying # of digits. */
413 print_longest (stream
, 'x', 1, val_long
);
422 print_longest (stream
, size
, 1, val_long
);
425 error ("Undefined output size \"%c\".", size
);
430 print_longest (stream
, 'd', 1, val_long
);
434 print_longest (stream
, 'u', 0, val_long
);
439 print_longest (stream
, 'o', 1, val_long
);
441 fprintf_filtered (stream
, "0");
446 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
447 print_address (addr
, stream
);
452 value_print (value_from_longest (builtin_type_true_char
, val_long
),
453 stream
, 0, Val_pretty_default
);
457 if (len
== TYPE_LENGTH (builtin_type_float
))
458 type
= builtin_type_float
;
459 else if (len
== TYPE_LENGTH (builtin_type_double
))
460 type
= builtin_type_double
;
461 else if (len
== TYPE_LENGTH (builtin_type_long_double
))
462 type
= builtin_type_long_double
;
463 print_floating (valaddr
, type
, stream
);
467 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
470 /* Binary; 't' stands for "two". */
472 char bits
[8 * (sizeof val_long
) + 1];
473 char buf
[8 * (sizeof val_long
) + 32];
478 width
= 8 * (sizeof val_long
);
495 error ("Undefined output size \"%c\".", size
);
501 bits
[width
] = (val_long
& 1) ? '1' : '0';
506 while (*cp
&& *cp
== '0')
511 strcpy (buf
, local_binary_format_prefix ());
513 strcat (buf
, local_binary_format_suffix ());
514 fprintf_filtered (stream
, buf
);
519 error ("Undefined output format \"%c\".", format
);
523 /* Specify default address for `x' command.
524 `info lines' uses this. */
527 set_next_address (CORE_ADDR addr
)
531 /* Make address available to the user as $_. */
532 set_internalvar (lookup_internalvar ("_"),
533 value_from_pointer (lookup_pointer_type (builtin_type_void
),
537 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
538 after LEADIN. Print nothing if no symbolic name is found nearby.
539 Optionally also print source file and line number, if available.
540 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
541 or to interpret it as a possible C++ name and convert it back to source
542 form. However note that DO_DEMANGLE can be overridden by the specific
543 settings of the demangle and asm_demangle variables. */
546 print_address_symbolic (CORE_ADDR addr
, struct ui_file
*stream
, int do_demangle
,
550 char *filename
= NULL
;
555 /* throw away both name and filename */
556 struct cleanup
*cleanup_chain
= make_cleanup (free_current_contents
, &name
);
557 make_cleanup (free_current_contents
, &filename
);
559 if (build_address_symbolic (addr
, do_demangle
, &name
, &offset
, &filename
, &line
, &unmapped
))
561 do_cleanups (cleanup_chain
);
565 fputs_filtered (leadin
, stream
);
567 fputs_filtered ("<*", stream
);
569 fputs_filtered ("<", stream
);
570 fputs_filtered (name
, stream
);
572 fprintf_filtered (stream
, "+%u", (unsigned int) offset
);
574 /* Append source filename and line number if desired. Give specific
575 line # of this addr, if we have it; else line # of the nearest symbol. */
576 if (print_symbol_filename
&& filename
!= NULL
)
579 fprintf_filtered (stream
, " at %s:%d", filename
, line
);
581 fprintf_filtered (stream
, " in %s", filename
);
584 fputs_filtered ("*>", stream
);
586 fputs_filtered (">", stream
);
588 do_cleanups (cleanup_chain
);
591 /* Given an address ADDR return all the elements needed to print the
592 address in a symbolic form. NAME can be mangled or not depending
593 on DO_DEMANGLE (and also on the asm_demangle global variable,
594 manipulated via ''set print asm-demangle''). Return 0 in case of
595 success, when all the info in the OUT paramters is valid. Return 1
598 build_address_symbolic (CORE_ADDR addr
, /* IN */
599 int do_demangle
, /* IN */
600 char **name
, /* OUT */
601 int *offset
, /* OUT */
602 char **filename
, /* OUT */
604 int *unmapped
) /* OUT */
606 struct minimal_symbol
*msymbol
;
607 struct symbol
*symbol
;
608 struct symtab
*symtab
= 0;
609 CORE_ADDR name_location
= 0;
610 asection
*section
= 0;
611 char *name_temp
= "";
613 /* Let's say it is unmapped. */
616 /* Determine if the address is in an overlay, and whether it is
618 if (overlay_debugging
)
620 section
= find_pc_overlay (addr
);
621 if (pc_in_unmapped_range (addr
, section
))
624 addr
= overlay_mapped_address (addr
, section
);
628 /* First try to find the address in the symbol table, then
629 in the minsyms. Take the closest one. */
631 /* This is defective in the sense that it only finds text symbols. So
632 really this is kind of pointless--we should make sure that the
633 minimal symbols have everything we need (by changing that we could
634 save some memory, but for many debug format--ELF/DWARF or
635 anything/stabs--it would be inconvenient to eliminate those minimal
637 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
638 symbol
= find_pc_sect_function (addr
, section
);
642 name_location
= BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
));
643 if (do_demangle
|| asm_demangle
)
644 name_temp
= SYMBOL_PRINT_NAME (symbol
);
646 name_temp
= DEPRECATED_SYMBOL_NAME (symbol
);
651 if (SYMBOL_VALUE_ADDRESS (msymbol
) > name_location
|| symbol
== NULL
)
653 /* The msymbol is closer to the address than the symbol;
654 use the msymbol instead. */
657 name_location
= SYMBOL_VALUE_ADDRESS (msymbol
);
658 if (do_demangle
|| asm_demangle
)
659 name_temp
= SYMBOL_PRINT_NAME (msymbol
);
661 name_temp
= DEPRECATED_SYMBOL_NAME (msymbol
);
664 if (symbol
== NULL
&& msymbol
== NULL
)
667 /* If the nearest symbol is too far away, don't print anything symbolic. */
669 /* For when CORE_ADDR is larger than unsigned int, we do math in
670 CORE_ADDR. But when we detect unsigned wraparound in the
671 CORE_ADDR math, we ignore this test and print the offset,
672 because addr+max_symbolic_offset has wrapped through the end
673 of the address space back to the beginning, giving bogus comparison. */
674 if (addr
> name_location
+ max_symbolic_offset
675 && name_location
+ max_symbolic_offset
> name_location
)
678 *offset
= addr
- name_location
;
680 *name
= xstrdup (name_temp
);
682 if (print_symbol_filename
)
684 struct symtab_and_line sal
;
686 sal
= find_pc_sect_line (addr
, section
, 0);
690 *filename
= xstrdup (sal
.symtab
->filename
);
693 else if (symtab
&& symbol
&& symbol
->line
)
695 *filename
= xstrdup (symtab
->filename
);
696 *line
= symbol
->line
;
700 *filename
= xstrdup (symtab
->filename
);
707 /* Print address ADDR on STREAM. USE_LOCAL means the same thing as for
710 print_address_numeric (CORE_ADDR addr
, int use_local
, struct ui_file
*stream
)
712 /* Truncate address to the size of a target address, avoiding shifts
713 larger or equal than the width of a CORE_ADDR. The local
714 variable ADDR_BIT stops the compiler reporting a shift overflow
715 when it won't occur. */
716 /* NOTE: This assumes that the significant address information is
717 kept in the least significant bits of ADDR - the upper bits were
718 either zero or sign extended. Should ADDRESS_TO_POINTER() or
719 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
721 int addr_bit
= TARGET_ADDR_BIT
;
723 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
724 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
725 print_longest (stream
, 'x', use_local
, (ULONGEST
) addr
);
728 /* Print address ADDR symbolically on STREAM.
729 First print it as a number. Then perhaps print
730 <SYMBOL + OFFSET> after the number. */
733 print_address (CORE_ADDR addr
, struct ui_file
*stream
)
735 print_address_numeric (addr
, 1, stream
);
736 print_address_symbolic (addr
, stream
, asm_demangle
, " ");
739 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
740 controls whether to print the symbolic name "raw" or demangled.
741 Global setting "addressprint" controls whether to print hex address
745 print_address_demangle (CORE_ADDR addr
, struct ui_file
*stream
, int do_demangle
)
749 fprintf_filtered (stream
, "0");
751 else if (addressprint
)
753 print_address_numeric (addr
, 1, stream
);
754 print_address_symbolic (addr
, stream
, do_demangle
, " ");
758 print_address_symbolic (addr
, stream
, do_demangle
, "");
763 /* These are the types that $__ will get after an examine command of one
766 static struct type
*examine_i_type
;
768 static struct type
*examine_b_type
;
769 static struct type
*examine_h_type
;
770 static struct type
*examine_w_type
;
771 static struct type
*examine_g_type
;
773 /* Examine data at address ADDR in format FMT.
774 Fetch it from memory and print on gdb_stdout. */
777 do_examine (struct format_data fmt
, CORE_ADDR addr
, asection
*sect
)
779 register char format
= 0;
781 register int count
= 1;
782 struct type
*val_type
= NULL
;
784 register int maxelts
;
792 /* String or instruction format implies fetch single bytes
793 regardless of the specified size. */
794 if (format
== 's' || format
== 'i')
798 val_type
= examine_i_type
;
799 else if (size
== 'b')
800 val_type
= examine_b_type
;
801 else if (size
== 'h')
802 val_type
= examine_h_type
;
803 else if (size
== 'w')
804 val_type
= examine_w_type
;
805 else if (size
== 'g')
806 val_type
= examine_g_type
;
813 if (format
== 's' || format
== 'i')
816 /* Print as many objects as specified in COUNT, at most maxelts per line,
817 with the address of the next one at the start of each line. */
822 print_address (next_address
, gdb_stdout
);
823 printf_filtered (":");
828 printf_filtered ("\t");
829 /* Note that print_formatted sets next_address for the next
831 last_examine_address
= next_address
;
833 if (last_examine_value
)
834 value_free (last_examine_value
);
836 /* The value to be displayed is not fetched greedily.
837 Instead, to avoid the posibility of a fetched value not
838 being used, its retreval is delayed until the print code
839 uses it. When examining an instruction stream, the
840 disassembler will perform its own memory fetch using just
841 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
842 the disassembler be modified so that LAST_EXAMINE_VALUE
843 is left with the byte sequence from the last complete
844 instruction fetched from memory? */
845 last_examine_value
= value_at_lazy (val_type
, next_address
, sect
);
847 if (last_examine_value
)
848 release_value (last_examine_value
);
850 print_formatted (last_examine_value
, format
, size
, gdb_stdout
);
852 printf_filtered ("\n");
853 gdb_flush (gdb_stdout
);
858 validate_format (struct format_data fmt
, char *cmdname
)
861 error ("Size letters are meaningless in \"%s\" command.", cmdname
);
863 error ("Item count other than 1 is meaningless in \"%s\" command.",
865 if (fmt
.format
== 'i' || fmt
.format
== 's')
866 error ("Format letter \"%c\" is meaningless in \"%s\" command.",
867 fmt
.format
, cmdname
);
870 /* Evaluate string EXP as an expression in the current language and
871 print the resulting value. EXP may contain a format specifier as the
872 first argument ("/x myvar" for example, to print myvar in hex).
876 print_command_1 (char *exp
, int inspect
, int voidprint
)
878 struct expression
*expr
;
879 register struct cleanup
*old_chain
= 0;
880 register char format
= 0;
882 struct format_data fmt
;
885 /* Pass inspect flag to the rest of the print routines in a global (sigh). */
886 inspect_it
= inspect
;
888 if (exp
&& *exp
== '/')
891 fmt
= decode_format (&exp
, last_format
, 0);
892 validate_format (fmt
, "print");
893 last_format
= format
= fmt
.format
;
905 expr
= parse_expression (exp
);
906 old_chain
= make_cleanup (free_current_contents
, &expr
);
908 val
= evaluate_expression (expr
);
911 val
= access_value_history (0);
913 if (voidprint
|| (val
&& VALUE_TYPE (val
) &&
914 TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_VOID
))
916 int histindex
= record_latest_value (val
);
919 annotate_value_history_begin (histindex
, VALUE_TYPE (val
));
921 annotate_value_begin (VALUE_TYPE (val
));
924 printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"", exp
, histindex
);
925 else if (histindex
>= 0)
926 printf_filtered ("$%d = ", histindex
);
929 annotate_value_history_value ();
931 print_formatted (val
, format
, fmt
.size
, gdb_stdout
);
932 printf_filtered ("\n");
935 annotate_value_history_end ();
937 annotate_value_end ();
940 printf_unfiltered ("\") )\030");
944 do_cleanups (old_chain
);
945 inspect_it
= 0; /* Reset print routines to normal */
950 print_command (char *exp
, int from_tty
)
952 print_command_1 (exp
, 0, 1);
955 /* Same as print, except in epoch, it gets its own window */
958 inspect_command (char *exp
, int from_tty
)
960 extern int epoch_interface
;
962 print_command_1 (exp
, epoch_interface
, 1);
965 /* Same as print, except it doesn't print void results. */
968 call_command (char *exp
, int from_tty
)
970 print_command_1 (exp
, 0, 0);
975 output_command (char *exp
, int from_tty
)
977 struct expression
*expr
;
978 register struct cleanup
*old_chain
;
979 register char format
= 0;
981 struct format_data fmt
;
983 if (exp
&& *exp
== '/')
986 fmt
= decode_format (&exp
, 0, 0);
987 validate_format (fmt
, "output");
991 expr
= parse_expression (exp
);
992 old_chain
= make_cleanup (free_current_contents
, &expr
);
994 val
= evaluate_expression (expr
);
996 annotate_value_begin (VALUE_TYPE (val
));
998 print_formatted (val
, format
, fmt
.size
, gdb_stdout
);
1000 annotate_value_end ();
1003 gdb_flush (gdb_stdout
);
1005 do_cleanups (old_chain
);
1010 set_command (char *exp
, int from_tty
)
1012 struct expression
*expr
= parse_expression (exp
);
1013 register struct cleanup
*old_chain
=
1014 make_cleanup (free_current_contents
, &expr
);
1015 evaluate_expression (expr
);
1016 do_cleanups (old_chain
);
1021 sym_info (char *arg
, int from_tty
)
1023 struct minimal_symbol
*msymbol
;
1024 struct objfile
*objfile
;
1025 struct obj_section
*osect
;
1027 CORE_ADDR addr
, sect_addr
;
1029 unsigned int offset
;
1032 error_no_arg ("address");
1034 addr
= parse_and_eval_address (arg
);
1035 ALL_OBJSECTIONS (objfile
, osect
)
1037 sect
= osect
->the_bfd_section
;
1038 sect_addr
= overlay_mapped_address (addr
, sect
);
1040 if (osect
->addr
<= sect_addr
&& sect_addr
< osect
->endaddr
&&
1041 (msymbol
= lookup_minimal_symbol_by_pc_section (sect_addr
, sect
)))
1044 offset
= sect_addr
- SYMBOL_VALUE_ADDRESS (msymbol
);
1046 printf_filtered ("%s + %u in ",
1047 SYMBOL_PRINT_NAME (msymbol
), offset
);
1049 printf_filtered ("%s in ",
1050 SYMBOL_PRINT_NAME (msymbol
));
1051 if (pc_in_unmapped_range (addr
, sect
))
1052 printf_filtered ("load address range of ");
1053 if (section_is_overlay (sect
))
1054 printf_filtered ("%s overlay ",
1055 section_is_mapped (sect
) ? "mapped" : "unmapped");
1056 printf_filtered ("section %s", sect
->name
);
1057 printf_filtered ("\n");
1061 printf_filtered ("No symbol matches %s.\n", arg
);
1066 address_info (char *exp
, int from_tty
)
1068 register struct symbol
*sym
;
1069 register struct minimal_symbol
*msymbol
;
1071 register long basereg
;
1073 CORE_ADDR load_addr
;
1074 int is_a_field_of_this
; /* C++: lookup_symbol sets this to nonzero
1075 if exp is a field of `this'. */
1078 error ("Argument required.");
1080 sym
= lookup_symbol (exp
, get_selected_block (0), VAR_NAMESPACE
,
1081 &is_a_field_of_this
, (struct symtab
**) NULL
);
1084 if (is_a_field_of_this
)
1086 printf_filtered ("Symbol \"");
1087 fprintf_symbol_filtered (gdb_stdout
, exp
,
1088 current_language
->la_language
, DMGL_ANSI
);
1089 printf_filtered ("\" is a field of the local class variable ");
1090 if (current_language
->la_language
== language_objc
)
1091 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1093 printf_filtered ("`this'\n");
1097 msymbol
= lookup_minimal_symbol (exp
, NULL
, NULL
);
1099 if (msymbol
!= NULL
)
1101 load_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1103 printf_filtered ("Symbol \"");
1104 fprintf_symbol_filtered (gdb_stdout
, exp
,
1105 current_language
->la_language
, DMGL_ANSI
);
1106 printf_filtered ("\" is at ");
1107 print_address_numeric (load_addr
, 1, gdb_stdout
);
1108 printf_filtered (" in a file compiled without debugging");
1109 section
= SYMBOL_BFD_SECTION (msymbol
);
1110 if (section_is_overlay (section
))
1112 load_addr
= overlay_unmapped_address (load_addr
, section
);
1113 printf_filtered (",\n -- loaded at ");
1114 print_address_numeric (load_addr
, 1, gdb_stdout
);
1115 printf_filtered (" in overlay section %s", section
->name
);
1117 printf_filtered (".\n");
1120 error ("No symbol \"%s\" in current context.", exp
);
1124 printf_filtered ("Symbol \"");
1125 fprintf_symbol_filtered (gdb_stdout
, DEPRECATED_SYMBOL_NAME (sym
),
1126 current_language
->la_language
, DMGL_ANSI
);
1127 printf_filtered ("\" is ");
1128 val
= SYMBOL_VALUE (sym
);
1129 basereg
= SYMBOL_BASEREG (sym
);
1130 section
= SYMBOL_BFD_SECTION (sym
);
1132 switch (SYMBOL_CLASS (sym
))
1135 case LOC_CONST_BYTES
:
1136 printf_filtered ("constant");
1140 printf_filtered ("a label at address ");
1141 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1143 if (section_is_overlay (section
))
1145 load_addr
= overlay_unmapped_address (load_addr
, section
);
1146 printf_filtered (",\n -- loaded at ");
1147 print_address_numeric (load_addr
, 1, gdb_stdout
);
1148 printf_filtered (" in overlay section %s", section
->name
);
1153 case LOC_COMPUTED_ARG
:
1154 (SYMBOL_LOCATION_FUNCS (sym
)->describe_location
) (sym
, gdb_stdout
);
1158 printf_filtered ("a variable in register %s", REGISTER_NAME (val
));
1162 printf_filtered ("static storage at address ");
1163 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1165 if (section_is_overlay (section
))
1167 load_addr
= overlay_unmapped_address (load_addr
, section
);
1168 printf_filtered (",\n -- loaded at ");
1169 print_address_numeric (load_addr
, 1, gdb_stdout
);
1170 printf_filtered (" in overlay section %s", section
->name
);
1175 printf_filtered ("external global (indirect addressing), at address *(");
1176 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1178 printf_filtered (")");
1179 if (section_is_overlay (section
))
1181 load_addr
= overlay_unmapped_address (load_addr
, section
);
1182 printf_filtered (",\n -- loaded at ");
1183 print_address_numeric (load_addr
, 1, gdb_stdout
);
1184 printf_filtered (" in overlay section %s", section
->name
);
1189 printf_filtered ("an argument in register %s", REGISTER_NAME (val
));
1192 case LOC_REGPARM_ADDR
:
1193 printf_filtered ("address of an argument in register %s", REGISTER_NAME (val
));
1197 printf_filtered ("an argument at offset %ld", val
);
1201 printf_filtered ("an argument at frame offset %ld", val
);
1205 printf_filtered ("a local variable at frame offset %ld", val
);
1209 printf_filtered ("a reference argument at offset %ld", val
);
1213 printf_filtered ("a variable at offset %ld from register %s",
1214 val
, REGISTER_NAME (basereg
));
1217 case LOC_BASEREG_ARG
:
1218 printf_filtered ("an argument at offset %ld from register %s",
1219 val
, REGISTER_NAME (basereg
));
1223 printf_filtered ("a typedef");
1227 printf_filtered ("a function at address ");
1228 print_address_numeric (load_addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)),
1230 if (section_is_overlay (section
))
1232 load_addr
= overlay_unmapped_address (load_addr
, section
);
1233 printf_filtered (",\n -- loaded at ");
1234 print_address_numeric (load_addr
, 1, gdb_stdout
);
1235 printf_filtered (" in overlay section %s", section
->name
);
1239 case LOC_UNRESOLVED
:
1241 struct minimal_symbol
*msym
;
1243 msym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym
), NULL
, NULL
);
1245 printf_filtered ("unresolved");
1248 section
= SYMBOL_BFD_SECTION (msym
);
1249 printf_filtered ("static storage at address ");
1250 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (msym
),
1252 if (section_is_overlay (section
))
1254 load_addr
= overlay_unmapped_address (load_addr
, section
);
1255 printf_filtered (",\n -- loaded at ");
1256 print_address_numeric (load_addr
, 1, gdb_stdout
);
1257 printf_filtered (" in overlay section %s", section
->name
);
1263 case LOC_HP_THREAD_LOCAL_STATIC
:
1265 "a thread-local variable at offset %ld from the thread base register %s",
1266 val
, REGISTER_NAME (basereg
));
1269 case LOC_THREAD_LOCAL_STATIC
:
1270 printf_filtered ("a thread-local variable at offset %ld in the "
1271 "thread-local storage for `%s'",
1272 val
, SYMBOL_OBJFILE (sym
)->name
);
1275 case LOC_OPTIMIZED_OUT
:
1276 printf_filtered ("optimized out");
1280 printf_filtered ("of unknown (botched) type");
1283 printf_filtered (".\n");
1287 x_command (char *exp
, int from_tty
)
1289 struct expression
*expr
;
1290 struct format_data fmt
;
1291 struct cleanup
*old_chain
;
1294 fmt
.format
= last_format
;
1295 fmt
.size
= last_size
;
1298 if (exp
&& *exp
== '/')
1301 fmt
= decode_format (&exp
, last_format
, last_size
);
1304 /* If we have an expression, evaluate it and use it as the address. */
1306 if (exp
!= 0 && *exp
!= 0)
1308 expr
= parse_expression (exp
);
1309 /* Cause expression not to be there any more
1310 if this command is repeated with Newline.
1311 But don't clobber a user-defined command's definition. */
1314 old_chain
= make_cleanup (free_current_contents
, &expr
);
1315 val
= evaluate_expression (expr
);
1316 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_REF
)
1317 val
= value_ind (val
);
1318 /* In rvalue contexts, such as this, functions are coerced into
1319 pointers to functions. This makes "x/i main" work. */
1320 if (/* last_format == 'i' && */
1321 TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FUNC
1322 && VALUE_LVAL (val
) == lval_memory
)
1323 next_address
= VALUE_ADDRESS (val
);
1325 next_address
= value_as_address (val
);
1326 if (VALUE_BFD_SECTION (val
))
1327 next_section
= VALUE_BFD_SECTION (val
);
1328 do_cleanups (old_chain
);
1331 do_examine (fmt
, next_address
, next_section
);
1333 /* If the examine succeeds, we remember its size and format for next time. */
1334 last_size
= fmt
.size
;
1335 last_format
= fmt
.format
;
1337 /* Set a couple of internal variables if appropriate. */
1338 if (last_examine_value
)
1340 /* Make last address examined available to the user as $_. Use
1341 the correct pointer type. */
1342 struct type
*pointer_type
1343 = lookup_pointer_type (VALUE_TYPE (last_examine_value
));
1344 set_internalvar (lookup_internalvar ("_"),
1345 value_from_pointer (pointer_type
,
1346 last_examine_address
));
1348 /* Make contents of last address examined available to the user as $__. */
1349 /* If the last value has not been fetched from memory then don't
1350 fetch it now - instead mark it by voiding the $__ variable. */
1351 if (VALUE_LAZY (last_examine_value
))
1352 set_internalvar (lookup_internalvar ("__"),
1353 allocate_value (builtin_type_void
));
1355 set_internalvar (lookup_internalvar ("__"), last_examine_value
);
1360 /* Add an expression to the auto-display chain.
1361 Specify the expression. */
1364 display_command (char *exp
, int from_tty
)
1366 struct format_data fmt
;
1367 register struct expression
*expr
;
1368 register struct display
*new;
1372 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1374 if (tui_active
&& *exp
== '$')
1375 display_it
= (tui_set_layout (exp
) == TUI_FAILURE
);
1389 fmt
= decode_format (&exp
, 0, 0);
1390 if (fmt
.size
&& fmt
.format
== 0)
1392 if (fmt
.format
== 'i' || fmt
.format
== 's')
1402 innermost_block
= 0;
1403 expr
= parse_expression (exp
);
1405 new = (struct display
*) xmalloc (sizeof (struct display
));
1408 new->block
= innermost_block
;
1409 new->next
= display_chain
;
1410 new->number
= ++display_number
;
1413 display_chain
= new;
1415 if (from_tty
&& target_has_execution
)
1416 do_one_display (new);
1423 free_display (struct display
*d
)
1429 /* Clear out the display_chain.
1430 Done when new symtabs are loaded, since this invalidates
1431 the types stored in many expressions. */
1434 clear_displays (void)
1436 register struct display
*d
;
1438 while ((d
= display_chain
) != NULL
)
1441 display_chain
= d
->next
;
1446 /* Delete the auto-display number NUM. */
1449 delete_display (int num
)
1451 register struct display
*d1
, *d
;
1454 error ("No display number %d.", num
);
1456 if (display_chain
->number
== num
)
1459 display_chain
= d1
->next
;
1463 for (d
= display_chain
;; d
= d
->next
)
1466 error ("No display number %d.", num
);
1467 if (d
->next
->number
== num
)
1477 /* Delete some values from the auto-display chain.
1478 Specify the element numbers. */
1481 undisplay_command (char *args
, int from_tty
)
1483 register char *p
= args
;
1489 if (query ("Delete all auto-display expressions? "))
1498 while (*p1
>= '0' && *p1
<= '9')
1500 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1501 error ("Arguments must be display numbers.");
1505 delete_display (num
);
1508 while (*p
== ' ' || *p
== '\t')
1514 /* Display a single auto-display.
1515 Do nothing if the display cannot be printed in the current context,
1516 or if the display is disabled. */
1519 do_one_display (struct display
*d
)
1521 int within_current_scope
;
1523 if (d
->enabled_p
== 0)
1527 within_current_scope
= contained_in (get_selected_block (0), d
->block
);
1529 within_current_scope
= 1;
1530 if (!within_current_scope
)
1533 current_display_number
= d
->number
;
1535 annotate_display_begin ();
1536 printf_filtered ("%d", d
->number
);
1537 annotate_display_number_end ();
1538 printf_filtered (": ");
1544 annotate_display_format ();
1546 printf_filtered ("x/");
1547 if (d
->format
.count
!= 1)
1548 printf_filtered ("%d", d
->format
.count
);
1549 printf_filtered ("%c", d
->format
.format
);
1550 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1551 printf_filtered ("%c", d
->format
.size
);
1552 printf_filtered (" ");
1554 annotate_display_expression ();
1556 print_expression (d
->exp
, gdb_stdout
);
1557 annotate_display_expression_end ();
1559 if (d
->format
.count
!= 1)
1560 printf_filtered ("\n");
1562 printf_filtered (" ");
1564 val
= evaluate_expression (d
->exp
);
1565 addr
= value_as_address (val
);
1566 if (d
->format
.format
== 'i')
1567 addr
= ADDR_BITS_REMOVE (addr
);
1569 annotate_display_value ();
1571 do_examine (d
->format
, addr
, VALUE_BFD_SECTION (val
));
1575 annotate_display_format ();
1577 if (d
->format
.format
)
1578 printf_filtered ("/%c ", d
->format
.format
);
1580 annotate_display_expression ();
1582 print_expression (d
->exp
, gdb_stdout
);
1583 annotate_display_expression_end ();
1585 printf_filtered (" = ");
1587 annotate_display_expression ();
1589 print_formatted (evaluate_expression (d
->exp
),
1590 d
->format
.format
, d
->format
.size
, gdb_stdout
);
1591 printf_filtered ("\n");
1594 annotate_display_end ();
1596 gdb_flush (gdb_stdout
);
1597 current_display_number
= -1;
1600 /* Display all of the values on the auto-display chain which can be
1601 evaluated in the current scope. */
1606 register struct display
*d
;
1608 for (d
= display_chain
; d
; d
= d
->next
)
1612 /* Delete the auto-display which we were in the process of displaying.
1613 This is done when there is an error or a signal. */
1616 disable_display (int num
)
1618 register struct display
*d
;
1620 for (d
= display_chain
; d
; d
= d
->next
)
1621 if (d
->number
== num
)
1626 printf_unfiltered ("No display number %d.\n", num
);
1630 disable_current_display (void)
1632 if (current_display_number
>= 0)
1634 disable_display (current_display_number
);
1635 fprintf_unfiltered (gdb_stderr
, "Disabling display %d to avoid infinite recursion.\n",
1636 current_display_number
);
1638 current_display_number
= -1;
1642 display_info (char *ignore
, int from_tty
)
1644 register struct display
*d
;
1647 printf_unfiltered ("There are no auto-display expressions now.\n");
1649 printf_filtered ("Auto-display expressions now in effect:\n\
1650 Num Enb Expression\n");
1652 for (d
= display_chain
; d
; d
= d
->next
)
1654 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
1656 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
1658 else if (d
->format
.format
)
1659 printf_filtered ("/%c ", d
->format
.format
);
1660 print_expression (d
->exp
, gdb_stdout
);
1661 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
))
1662 printf_filtered (" (cannot be evaluated in the current context)");
1663 printf_filtered ("\n");
1664 gdb_flush (gdb_stdout
);
1669 enable_display (char *args
, int from_tty
)
1671 register char *p
= args
;
1674 register struct display
*d
;
1678 for (d
= display_chain
; d
; d
= d
->next
)
1685 while (*p1
>= '0' && *p1
<= '9')
1687 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1688 error ("Arguments must be display numbers.");
1692 for (d
= display_chain
; d
; d
= d
->next
)
1693 if (d
->number
== num
)
1698 printf_unfiltered ("No display number %d.\n", num
);
1701 while (*p
== ' ' || *p
== '\t')
1708 disable_display_command (char *args
, int from_tty
)
1710 register char *p
= args
;
1712 register struct display
*d
;
1716 for (d
= display_chain
; d
; d
= d
->next
)
1723 while (*p1
>= '0' && *p1
<= '9')
1725 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1726 error ("Arguments must be display numbers.");
1728 disable_display (atoi (p
));
1731 while (*p
== ' ' || *p
== '\t')
1737 /* Print the value in stack frame FRAME of a variable
1738 specified by a struct symbol. */
1741 print_variable_value (struct symbol
*var
, struct frame_info
*frame
,
1742 struct ui_file
*stream
)
1744 struct value
*val
= read_var_value (var
, frame
);
1746 value_print (val
, stream
, 0, Val_pretty_default
);
1749 /* Print the arguments of a stack frame, given the function FUNC
1750 running in that frame (as a symbol), the info on the frame,
1751 and the number of args according to the stack frame (or -1 if unknown). */
1753 /* References here and elsewhere to "number of args according to the
1754 stack frame" appear in all cases to refer to "number of ints of args
1755 according to the stack frame". At least for VAX, i386, isi. */
1758 print_frame_args (struct symbol
*func
, struct frame_info
*fi
, int num
,
1759 struct ui_file
*stream
)
1761 struct block
*b
= NULL
;
1764 register struct symbol
*sym
;
1766 /* Offset of next stack argument beyond the one we have seen that is
1767 at the highest offset.
1768 -1 if we haven't come to a stack argument yet. */
1769 long highest_offset
= -1;
1771 /* Number of ints of arguments that we have printed so far. */
1772 int args_printed
= 0;
1773 struct cleanup
*old_chain
, *list_chain
;
1774 struct ui_stream
*stb
;
1776 stb
= ui_out_stream_new (uiout
);
1777 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1781 b
= SYMBOL_BLOCK_VALUE (func
);
1782 /* Function blocks are order sensitive, and thus should not be
1784 gdb_assert (BLOCK_HASHTABLE (b
) == 0);
1786 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
1790 /* Keep track of the highest stack argument offset seen, and
1791 skip over any kinds of symbols we don't care about. */
1793 switch (SYMBOL_CLASS (sym
))
1798 long current_offset
= SYMBOL_VALUE (sym
);
1799 arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
1801 /* Compute address of next argument by adding the size of
1802 this argument and rounding to an int boundary. */
1804 ((current_offset
+ arg_size
+ sizeof (int) - 1)
1805 & ~(sizeof (int) - 1));
1807 /* If this is the highest offset seen yet, set highest_offset. */
1808 if (highest_offset
== -1
1809 || (current_offset
> highest_offset
))
1810 highest_offset
= current_offset
;
1812 /* Add the number of ints we're about to print to args_printed. */
1813 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
1816 /* We care about types of symbols, but don't need to keep track of
1817 stack offsets in them. */
1819 case LOC_REGPARM_ADDR
:
1821 case LOC_BASEREG_ARG
:
1822 case LOC_COMPUTED_ARG
:
1825 /* Other types of symbols we just skip over. */
1830 /* We have to look up the symbol because arguments can have
1831 two entries (one a parameter, one a local) and the one we
1832 want is the local, which lookup_symbol will find for us.
1833 This includes gcc1 (not gcc2) on the sparc when passing a
1834 small structure and gcc2 when the argument type is float
1835 and it is passed as a double and converted to float by
1836 the prologue (in the latter case the type of the LOC_ARG
1837 symbol is double and the type of the LOC_LOCAL symbol is
1839 /* But if the parameter name is null, don't try it.
1840 Null parameter names occur on the RS/6000, for traceback tables.
1841 FIXME, should we even print them? */
1843 if (*DEPRECATED_SYMBOL_NAME (sym
))
1845 struct symbol
*nsym
;
1846 nsym
= lookup_symbol
1847 (DEPRECATED_SYMBOL_NAME (sym
),
1848 b
, VAR_NAMESPACE
, (int *) NULL
, (struct symtab
**) NULL
);
1849 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
)
1851 /* There is a LOC_ARG/LOC_REGISTER pair. This means that
1852 it was passed on the stack and loaded into a register,
1853 or passed in a register and stored in a stack slot.
1854 GDB 3.x used the LOC_ARG; GDB 4.0-4.11 used the LOC_REGISTER.
1856 Reasons for using the LOC_ARG:
1857 (1) because find_saved_registers may be slow for remote
1859 (2) because registers are often re-used and stack slots
1860 rarely (never?) are. Therefore using the stack slot is
1861 much less likely to print garbage.
1863 Reasons why we might want to use the LOC_REGISTER:
1864 (1) So that the backtrace prints the same value as
1865 "print foo". I see no compelling reason why this needs
1866 to be the case; having the backtrace print the value which
1867 was passed in, and "print foo" print the value as modified
1868 within the called function, makes perfect sense to me.
1870 Additional note: It might be nice if "info args" displayed
1872 One more note: There is a case with sparc structure passing
1873 where we need to use the LOC_REGISTER, but this is dealt with
1874 by creating a single LOC_REGPARM in symbol reading. */
1876 /* Leave sym (the LOC_ARG) alone. */
1883 /* Print the current arg. */
1885 ui_out_text (uiout
, ", ");
1886 ui_out_wrap_hint (uiout
, " ");
1888 annotate_arg_begin ();
1890 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1891 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (sym
),
1892 SYMBOL_LANGUAGE (sym
), DMGL_PARAMS
| DMGL_ANSI
);
1893 ui_out_field_stream (uiout
, "name", stb
);
1894 annotate_arg_name_end ();
1895 ui_out_text (uiout
, "=");
1897 /* Avoid value_print because it will deref ref parameters. We just
1898 want to print their addresses. Print ??? for args whose address
1899 we do not know. We pass 2 as "recurse" to val_print because our
1900 standard indentation here is 4 spaces, and val_print indents
1901 2 for each recurse. */
1902 val
= read_var_value (sym
, fi
);
1904 annotate_arg_value (val
== NULL
? NULL
: VALUE_TYPE (val
));
1908 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
), 0,
1909 VALUE_ADDRESS (val
),
1910 stb
->stream
, 0, 0, 2, Val_no_prettyprint
);
1911 ui_out_field_stream (uiout
, "value", stb
);
1914 ui_out_text (uiout
, "???");
1916 /* Invoke ui_out_tuple_end. */
1917 do_cleanups (list_chain
);
1919 annotate_arg_end ();
1925 /* Don't print nameless args in situations where we don't know
1926 enough about the stack to find them. */
1931 if (highest_offset
== -1)
1932 start
= FRAME_ARGS_SKIP
;
1934 start
= highest_offset
;
1936 print_frame_nameless_args (fi
, start
, num
- args_printed
,
1939 do_cleanups (old_chain
);
1942 /* Print nameless args on STREAM.
1943 FI is the frameinfo for this frame, START is the offset
1944 of the first nameless arg, and NUM is the number of nameless args to
1945 print. FIRST is nonzero if this is the first argument (not just
1946 the first nameless arg). */
1949 print_frame_nameless_args (struct frame_info
*fi
, long start
, int num
,
1950 int first
, struct ui_file
*stream
)
1956 for (i
= 0; i
< num
; i
++)
1959 #ifdef NAMELESS_ARG_VALUE
1960 NAMELESS_ARG_VALUE (fi
, start
, &arg_value
);
1962 argsaddr
= get_frame_args_address (fi
);
1966 arg_value
= read_memory_integer (argsaddr
+ start
, sizeof (int));
1970 fprintf_filtered (stream
, ", ");
1972 #ifdef PRINT_NAMELESS_INTEGER
1973 PRINT_NAMELESS_INTEGER (stream
, arg_value
);
1975 #ifdef PRINT_TYPELESS_INTEGER
1976 PRINT_TYPELESS_INTEGER (stream
, builtin_type_int
, (LONGEST
) arg_value
);
1978 fprintf_filtered (stream
, "%ld", arg_value
);
1979 #endif /* PRINT_TYPELESS_INTEGER */
1980 #endif /* PRINT_NAMELESS_INTEGER */
1982 start
+= sizeof (int);
1988 printf_command (char *arg
, int from_tty
)
1990 register char *f
= NULL
;
1991 register char *s
= arg
;
1992 char *string
= NULL
;
1993 struct value
**val_args
;
1995 char *current_substring
;
1997 int allocated_args
= 20;
1998 struct cleanup
*old_cleanups
;
2000 val_args
= (struct value
**) xmalloc (allocated_args
2001 * sizeof (struct value
*));
2002 old_cleanups
= make_cleanup (free_current_contents
, &val_args
);
2005 error_no_arg ("format-control string and values to print");
2007 /* Skip white space before format string */
2008 while (*s
== ' ' || *s
== '\t')
2011 /* A format string should follow, enveloped in double quotes */
2013 error ("Bad format string, missing '\"'.");
2015 /* Parse the format-control string and copy it into the string STRING,
2016 processing some kinds of escape sequence. */
2018 f
= string
= (char *) alloca (strlen (s
) + 1);
2026 error ("Bad format string, non-terminated '\"'.");
2059 /* ??? TODO: handle other escape sequences */
2060 error ("Unrecognized escape character \\%c in format string.",
2070 /* Skip over " and following space and comma. */
2073 while (*s
== ' ' || *s
== '\t')
2076 if (*s
!= ',' && *s
!= 0)
2077 error ("Invalid argument syntax");
2081 while (*s
== ' ' || *s
== '\t')
2084 /* Need extra space for the '\0's. Doubling the size is sufficient. */
2085 substrings
= alloca (strlen (string
) * 2);
2086 current_substring
= substrings
;
2089 /* Now scan the string for %-specs and see what kinds of args they want.
2090 argclass[I] classifies the %-specs so we can give printf_filtered
2091 something of the right size. */
2095 no_arg
, int_arg
, string_arg
, double_arg
, long_long_arg
2097 enum argclass
*argclass
;
2098 enum argclass this_argclass
;
2104 argclass
= (enum argclass
*) alloca (strlen (s
) * sizeof *argclass
);
2112 while (strchr ("0123456789.hlL-+ #", *f
))
2114 if (*f
== 'l' || *f
== 'L')
2121 this_argclass
= string_arg
;
2127 this_argclass
= double_arg
;
2131 error ("`*' not supported for precision or width in printf");
2134 error ("Format specifier `n' not supported in printf");
2137 this_argclass
= no_arg
;
2142 this_argclass
= long_long_arg
;
2144 this_argclass
= int_arg
;
2148 if (this_argclass
!= no_arg
)
2150 strncpy (current_substring
, last_arg
, f
- last_arg
);
2151 current_substring
+= f
- last_arg
;
2152 *current_substring
++ = '\0';
2154 argclass
[nargs_wanted
++] = this_argclass
;
2158 /* Now, parse all arguments and evaluate them.
2159 Store the VALUEs in VAL_ARGS. */
2164 if (nargs
== allocated_args
)
2165 val_args
= (struct value
**) xrealloc ((char *) val_args
,
2166 (allocated_args
*= 2)
2167 * sizeof (struct value
*));
2169 val_args
[nargs
] = parse_to_comma_and_eval (&s1
);
2171 /* If format string wants a float, unchecked-convert the value to
2172 floating point of the same size */
2174 if (argclass
[nargs
] == double_arg
)
2176 struct type
*type
= VALUE_TYPE (val_args
[nargs
]);
2177 if (TYPE_LENGTH (type
) == sizeof (float))
2178 VALUE_TYPE (val_args
[nargs
]) = builtin_type_float
;
2179 if (TYPE_LENGTH (type
) == sizeof (double))
2180 VALUE_TYPE (val_args
[nargs
]) = builtin_type_double
;
2188 if (nargs
!= nargs_wanted
)
2189 error ("Wrong number of arguments for specified format-string");
2191 /* Now actually print them. */
2192 current_substring
= substrings
;
2193 for (i
= 0; i
< nargs
; i
++)
2195 switch (argclass
[i
])
2202 tem
= value_as_address (val_args
[i
]);
2204 /* This is a %s argument. Find the length of the string. */
2209 read_memory (tem
+ j
, &c
, 1);
2214 /* Copy the string contents into a string inside GDB. */
2215 str
= (char *) alloca (j
+ 1);
2217 read_memory (tem
, str
, j
);
2220 printf_filtered (current_substring
, str
);
2225 double val
= value_as_double (val_args
[i
]);
2226 printf_filtered (current_substring
, val
);
2230 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2232 long long val
= value_as_long (val_args
[i
]);
2233 printf_filtered (current_substring
, val
);
2237 error ("long long not supported in printf");
2241 /* FIXME: there should be separate int_arg and long_arg. */
2242 long val
= value_as_long (val_args
[i
]);
2243 printf_filtered (current_substring
, val
);
2246 default: /* purecov: deadcode */
2247 error ("internal error in printf_command"); /* purecov: deadcode */
2249 /* Skip to the next substring. */
2250 current_substring
+= strlen (current_substring
) + 1;
2252 /* Print the portion of the format string after the last argument. */
2253 printf_filtered (last_arg
);
2255 do_cleanups (old_cleanups
);
2258 /* Print the instruction at address MEMADDR in debugged memory,
2259 on STREAM. Returns length of the instruction, in bytes. */
2262 print_insn (CORE_ADDR memaddr
, struct ui_file
*stream
)
2264 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
2265 TARGET_PRINT_INSN_INFO
->endian
= BFD_ENDIAN_BIG
;
2267 TARGET_PRINT_INSN_INFO
->endian
= BFD_ENDIAN_LITTLE
;
2269 if (TARGET_ARCHITECTURE
!= NULL
)
2270 TARGET_PRINT_INSN_INFO
->mach
= TARGET_ARCHITECTURE
->mach
;
2271 /* else: should set .mach=0 but some disassemblers don't grok this */
2273 TARGET_PRINT_INSN_INFO
->stream
= stream
;
2275 return TARGET_PRINT_INSN (memaddr
, TARGET_PRINT_INSN_INFO
);
2280 _initialize_printcmd (void)
2282 struct cmd_list_element
*c
;
2284 current_display_number
= -1;
2286 add_info ("address", address_info
,
2287 "Describe where symbol SYM is stored.");
2289 add_info ("symbol", sym_info
,
2290 "Describe what symbol is at location ADDR.\n\
2291 Only for symbols with fixed locations (global or static scope).");
2293 add_com ("x", class_vars
, x_command
,
2294 concat ("Examine memory: x/FMT ADDRESS.\n\
2295 ADDRESS is an expression for the memory address to examine.\n\
2296 FMT is a repeat count followed by a format letter and a size letter.\n\
2297 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2298 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n",
2299 "Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2300 The specified number of objects of the specified size are printed\n\
2301 according to the format.\n\n\
2302 Defaults for format and size letters are those previously used.\n\
2303 Default count is 1. Default address is following last thing printed\n\
2304 with this command or \"print\".", NULL
));
2307 add_com ("whereis", class_vars
, whereis_command
,
2308 "Print line number and file of definition of variable.");
2311 add_info ("display", display_info
,
2312 "Expressions to display when program stops, with code numbers.");
2314 add_cmd ("undisplay", class_vars
, undisplay_command
,
2315 "Cancel some expressions to be displayed when program stops.\n\
2316 Arguments are the code numbers of the expressions to stop displaying.\n\
2317 No argument means cancel all automatic-display expressions.\n\
2318 \"delete display\" has the same effect as this command.\n\
2319 Do \"info display\" to see current list of code numbers.",
2322 add_com ("display", class_vars
, display_command
,
2323 "Print value of expression EXP each time the program stops.\n\
2324 /FMT may be used before EXP as in the \"print\" command.\n\
2325 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2326 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2327 and examining is done as in the \"x\" command.\n\n\
2328 With no argument, display all currently requested auto-display expressions.\n\
2329 Use \"undisplay\" to cancel display requests previously made."
2332 add_cmd ("display", class_vars
, enable_display
,
2333 "Enable some expressions to be displayed when program stops.\n\
2334 Arguments are the code numbers of the expressions to resume displaying.\n\
2335 No argument means enable all automatic-display expressions.\n\
2336 Do \"info display\" to see current list of code numbers.", &enablelist
);
2338 add_cmd ("display", class_vars
, disable_display_command
,
2339 "Disable some expressions to be displayed when program stops.\n\
2340 Arguments are the code numbers of the expressions to stop displaying.\n\
2341 No argument means disable all automatic-display expressions.\n\
2342 Do \"info display\" to see current list of code numbers.", &disablelist
);
2344 add_cmd ("display", class_vars
, undisplay_command
,
2345 "Cancel some expressions to be displayed when program stops.\n\
2346 Arguments are the code numbers of the expressions to stop displaying.\n\
2347 No argument means cancel all automatic-display expressions.\n\
2348 Do \"info display\" to see current list of code numbers.", &deletelist
);
2350 add_com ("printf", class_vars
, printf_command
,
2351 "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2352 This is useful for formatted output in user-defined commands.");
2354 add_com ("output", class_vars
, output_command
,
2355 "Like \"print\" but don't put in value history and don't print newline.\n\
2356 This is useful in user-defined commands.");
2358 add_prefix_cmd ("set", class_vars
, set_command
,
2359 concat ("Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2360 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2361 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2362 with $), a register (a few standard names starting with $), or an actual\n\
2363 variable in the program being debugged. EXP is any valid expression.\n",
2364 "Use \"set variable\" for variables with names identical to set subcommands.\n\
2365 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2366 You can see these environment settings with the \"show\" command.", NULL
),
2367 &setlist
, "set ", 1, &cmdlist
);
2369 add_com ("assign", class_vars
, set_command
, concat ("Evaluate expression \
2370 EXP and assign result to variable VAR, using assignment\n\
2371 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2372 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2373 with $), a register (a few standard names starting with $), or an actual\n\
2374 variable in the program being debugged. EXP is any valid expression.\n",
2375 "Use \"set variable\" for variables with names identical to set subcommands.\n\
2376 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2377 You can see these environment settings with the \"show\" command.", NULL
));
2379 /* "call" is the same as "set", but handy for dbx users to call fns. */
2380 c
= add_com ("call", class_vars
, call_command
,
2381 "Call a function in the program.\n\
2382 The argument is the function name and arguments, in the notation of the\n\
2383 current working language. The result is printed and saved in the value\n\
2384 history, if it is not void.");
2385 set_cmd_completer (c
, location_completer
);
2387 add_cmd ("variable", class_vars
, set_command
,
2388 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2389 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2390 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2391 with $), a register (a few standard names starting with $), or an actual\n\
2392 variable in the program being debugged. EXP is any valid expression.\n\
2393 This may usually be abbreviated to simply \"set\".",
2396 c
= add_com ("print", class_vars
, print_command
,
2397 concat ("Print value of expression EXP.\n\
2398 Variables accessible are those of the lexical environment of the selected\n\
2399 stack frame, plus all those whose scope is global or an entire file.\n\
2401 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2402 $$NUM refers to NUM'th value back from the last one.\n\
2403 Names starting with $ refer to registers (with the values they would have\n",
2404 "if the program were to return to the stack frame now selected, restoring\n\
2405 all registers saved by frames farther in) or else to debugger\n\
2406 \"convenience\" variables (any such name not a known register).\n\
2407 Use assignment expressions to give values to convenience variables.\n",
2409 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2410 @ is a binary operator for treating consecutive data objects\n\
2411 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2412 element is FOO, whose second element is stored in the space following\n\
2413 where FOO is stored, etc. FOO must be an expression whose value\n\
2414 resides in memory.\n",
2416 EXP may be preceded with /FMT, where FMT is a format letter\n\
2417 but no count or size letter (see \"x\" command).", NULL
));
2418 set_cmd_completer (c
, location_completer
);
2419 add_com_alias ("p", "print", class_vars
, 1);
2421 c
= add_com ("inspect", class_vars
, inspect_command
,
2422 "Same as \"print\" command, except that if you are running in the epoch\n\
2423 environment, the value is printed in its own window.");
2424 set_cmd_completer (c
, location_completer
);
2427 add_set_cmd ("max-symbolic-offset", no_class
, var_uinteger
,
2428 (char *) &max_symbolic_offset
,
2429 "Set the largest offset that will be printed in <symbol+1234> form.",
2433 add_set_cmd ("symbol-filename", no_class
, var_boolean
,
2434 (char *) &print_symbol_filename
,
2435 "Set printing of source filename and line number with <symbol>.",
2439 /* For examine/instruction a single byte quantity is specified as
2440 the data. This avoids problems with value_at_lazy() requiring a
2441 valid data type (and rejecting VOID). */
2442 examine_i_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_i_type", NULL
);
2444 examine_b_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_b_type", NULL
);
2445 examine_h_type
= init_type (TYPE_CODE_INT
, 2, 0, "examine_h_type", NULL
);
2446 examine_w_type
= init_type (TYPE_CODE_INT
, 4, 0, "examine_w_type", NULL
);
2447 examine_g_type
= init_type (TYPE_CODE_INT
, 8, 0, "examine_g_type", NULL
);