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 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 */
44 extern int asm_demangle
; /* Whether to demangle syms in asm printouts */
45 extern int addressprint
; /* Whether to print hex addresses in HLL " */
54 /* Last specified output format. */
56 static char last_format
= 'x';
58 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
60 static char last_size
= 'w';
62 /* Default address to examine next. */
64 static CORE_ADDR next_address
;
66 /* Default section to examine next. */
68 static asection
*next_section
;
70 /* Last address examined. */
72 static CORE_ADDR last_examine_address
;
74 /* Contents of last address examined.
75 This is not valid past the end of the `x' command! */
77 static struct value
*last_examine_value
;
79 /* Largest offset between a symbolic value and an address, that will be
80 printed as `0x1234 <symbol+offset>'. */
82 static unsigned int max_symbolic_offset
= UINT_MAX
;
84 /* Append the source filename and linenumber of the symbol when
85 printing a symbolic value as `<symbol at filename:linenum>' if set. */
86 static int print_symbol_filename
= 0;
88 /* Number of auto-display expression currently being displayed.
89 So that we can disable it if we get an error or a signal within it.
90 -1 when not doing one. */
92 int current_display_number
;
94 /* Flag to low-level print routines that this value is being printed
95 in an epoch window. We'd like to pass this as a parameter, but
96 every routine would need to take it. Perhaps we can encapsulate
97 this in the I/O stream once we have GNU stdio. */
103 /* Chain link to next auto-display item. */
104 struct display
*next
;
105 /* Expression to be evaluated and displayed. */
106 struct expression
*exp
;
107 /* Item number of this auto-display item. */
109 /* Display format specified. */
110 struct format_data format
;
111 /* Innermost block required by this expression when evaluated */
113 /* Status of this display (enabled or disabled) */
117 /* Chain of expressions whose values should be displayed
118 automatically each time the program stops. */
120 static struct display
*display_chain
;
122 static int display_number
;
124 /* Prototypes for exported functions. */
126 void output_command (char *, int);
128 void _initialize_printcmd (void);
130 /* Prototypes for local functions. */
132 static void delete_display (int);
134 static void enable_display (char *, int);
136 static void disable_display_command (char *, int);
138 static void disassemble_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 (char *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 is TARGET_ADDR_BIT, not
394 TYPE_LENGTH (type). */
395 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
396 len
= TARGET_ADDR_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 /* On some targets, add in extra "flag" bits to PC for
629 disassembly. This should ensure that "rounding errors" in
630 symbol addresses that are masked for disassembly favour the
631 the correct symbol. */
633 #ifdef GDB_TARGET_UNMASK_DISAS_PC
634 addr
= GDB_TARGET_UNMASK_DISAS_PC (addr
);
637 /* First try to find the address in the symbol table, then
638 in the minsyms. Take the closest one. */
640 /* This is defective in the sense that it only finds text symbols. So
641 really this is kind of pointless--we should make sure that the
642 minimal symbols have everything we need (by changing that we could
643 save some memory, but for many debug format--ELF/DWARF or
644 anything/stabs--it would be inconvenient to eliminate those minimal
646 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
647 symbol
= find_pc_sect_function (addr
, section
);
651 name_location
= BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
));
653 name_temp
= SYMBOL_SOURCE_NAME (symbol
);
655 name_temp
= SYMBOL_LINKAGE_NAME (symbol
);
660 if (SYMBOL_VALUE_ADDRESS (msymbol
) > name_location
|| symbol
== NULL
)
662 /* The msymbol is closer to the address than the symbol;
663 use the msymbol instead. */
666 name_location
= SYMBOL_VALUE_ADDRESS (msymbol
);
668 name_temp
= SYMBOL_SOURCE_NAME (msymbol
);
670 name_temp
= SYMBOL_LINKAGE_NAME (msymbol
);
673 if (symbol
== NULL
&& msymbol
== NULL
)
676 /* On some targets, mask out extra "flag" bits from PC for handsome
679 #ifdef GDB_TARGET_MASK_DISAS_PC
680 name_location
= GDB_TARGET_MASK_DISAS_PC (name_location
);
681 addr
= GDB_TARGET_MASK_DISAS_PC (addr
);
684 /* If the nearest symbol is too far away, don't print anything symbolic. */
686 /* For when CORE_ADDR is larger than unsigned int, we do math in
687 CORE_ADDR. But when we detect unsigned wraparound in the
688 CORE_ADDR math, we ignore this test and print the offset,
689 because addr+max_symbolic_offset has wrapped through the end
690 of the address space back to the beginning, giving bogus comparison. */
691 if (addr
> name_location
+ max_symbolic_offset
692 && name_location
+ max_symbolic_offset
> name_location
)
695 *offset
= addr
- name_location
;
697 *name
= xstrdup (name_temp
);
699 if (print_symbol_filename
)
701 struct symtab_and_line sal
;
703 sal
= find_pc_sect_line (addr
, section
, 0);
707 *filename
= xstrdup (sal
.symtab
->filename
);
710 else if (symtab
&& symbol
&& symbol
->line
)
712 *filename
= xstrdup (symtab
->filename
);
713 *line
= symbol
->line
;
717 *filename
= xstrdup (symtab
->filename
);
724 /* Print address ADDR on STREAM. USE_LOCAL means the same thing as for
727 print_address_numeric (CORE_ADDR addr
, int use_local
, struct ui_file
*stream
)
729 /* Truncate address to the size of a target address, avoiding shifts
730 larger or equal than the width of a CORE_ADDR. The local
731 variable ADDR_BIT stops the compiler reporting a shift overflow
732 when it won't occur. */
733 /* NOTE: This assumes that the significant address information is
734 kept in the least significant bits of ADDR - the upper bits were
735 either zero or sign extended. Should ADDRESS_TO_POINTER() or
736 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
738 int addr_bit
= TARGET_ADDR_BIT
;
740 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
741 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
742 print_longest (stream
, 'x', use_local
, (ULONGEST
) addr
);
745 /* Print address ADDR symbolically on STREAM.
746 First print it as a number. Then perhaps print
747 <SYMBOL + OFFSET> after the number. */
750 print_address (CORE_ADDR addr
, struct ui_file
*stream
)
752 print_address_numeric (addr
, 1, stream
);
753 print_address_symbolic (addr
, stream
, asm_demangle
, " ");
756 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
757 controls whether to print the symbolic name "raw" or demangled.
758 Global setting "addressprint" controls whether to print hex address
762 print_address_demangle (CORE_ADDR addr
, struct ui_file
*stream
, int do_demangle
)
766 fprintf_filtered (stream
, "0");
768 else if (addressprint
)
770 print_address_numeric (addr
, 1, stream
);
771 print_address_symbolic (addr
, stream
, do_demangle
, " ");
775 print_address_symbolic (addr
, stream
, do_demangle
, "");
780 /* These are the types that $__ will get after an examine command of one
783 static struct type
*examine_i_type
;
785 static struct type
*examine_b_type
;
786 static struct type
*examine_h_type
;
787 static struct type
*examine_w_type
;
788 static struct type
*examine_g_type
;
790 /* Examine data at address ADDR in format FMT.
791 Fetch it from memory and print on gdb_stdout. */
794 do_examine (struct format_data fmt
, CORE_ADDR addr
, asection
*sect
)
796 register char format
= 0;
798 register int count
= 1;
799 struct type
*val_type
= NULL
;
801 register int maxelts
;
809 /* String or instruction format implies fetch single bytes
810 regardless of the specified size. */
811 if (format
== 's' || format
== 'i')
815 val_type
= examine_i_type
;
816 else if (size
== 'b')
817 val_type
= examine_b_type
;
818 else if (size
== 'h')
819 val_type
= examine_h_type
;
820 else if (size
== 'w')
821 val_type
= examine_w_type
;
822 else if (size
== 'g')
823 val_type
= examine_g_type
;
830 if (format
== 's' || format
== 'i')
833 /* Print as many objects as specified in COUNT, at most maxelts per line,
834 with the address of the next one at the start of each line. */
839 print_address (next_address
, gdb_stdout
);
840 printf_filtered (":");
845 printf_filtered ("\t");
846 /* Note that print_formatted sets next_address for the next
848 last_examine_address
= next_address
;
850 if (last_examine_value
)
851 value_free (last_examine_value
);
853 /* The value to be displayed is not fetched greedily.
854 Instead, to avoid the posibility of a fetched value not
855 being used, its retreval is delayed until the print code
856 uses it. When examining an instruction stream, the
857 disassembler will perform its own memory fetch using just
858 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
859 the disassembler be modified so that LAST_EXAMINE_VALUE
860 is left with the byte sequence from the last complete
861 instruction fetched from memory? */
862 last_examine_value
= value_at_lazy (val_type
, next_address
, sect
);
864 if (last_examine_value
)
865 release_value (last_examine_value
);
867 print_formatted (last_examine_value
, format
, size
, gdb_stdout
);
869 printf_filtered ("\n");
870 gdb_flush (gdb_stdout
);
875 validate_format (struct format_data fmt
, char *cmdname
)
878 error ("Size letters are meaningless in \"%s\" command.", cmdname
);
880 error ("Item count other than 1 is meaningless in \"%s\" command.",
882 if (fmt
.format
== 'i' || fmt
.format
== 's')
883 error ("Format letter \"%c\" is meaningless in \"%s\" command.",
884 fmt
.format
, cmdname
);
887 /* Evaluate string EXP as an expression in the current language and
888 print the resulting value. EXP may contain a format specifier as the
889 first argument ("/x myvar" for example, to print myvar in hex).
893 print_command_1 (char *exp
, int inspect
, int voidprint
)
895 struct expression
*expr
;
896 register struct cleanup
*old_chain
= 0;
897 register char format
= 0;
899 struct format_data fmt
;
902 /* Pass inspect flag to the rest of the print routines in a global (sigh). */
903 inspect_it
= inspect
;
905 if (exp
&& *exp
== '/')
908 fmt
= decode_format (&exp
, last_format
, 0);
909 validate_format (fmt
, "print");
910 last_format
= format
= fmt
.format
;
922 expr
= parse_expression (exp
);
923 old_chain
= make_cleanup (free_current_contents
, &expr
);
925 val
= evaluate_expression (expr
);
927 /* C++: figure out what type we actually want to print it as. */
928 type
= VALUE_TYPE (val
);
931 && (TYPE_CODE (type
) == TYPE_CODE_PTR
932 || TYPE_CODE (type
) == TYPE_CODE_REF
)
933 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
934 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_UNION
))
938 v
= value_from_vtable_info (val
, TYPE_TARGET_TYPE (type
));
942 type
= VALUE_TYPE (val
);
947 val
= access_value_history (0);
949 if (voidprint
|| (val
&& VALUE_TYPE (val
) &&
950 TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_VOID
))
952 int histindex
= record_latest_value (val
);
955 annotate_value_history_begin (histindex
, VALUE_TYPE (val
));
957 annotate_value_begin (VALUE_TYPE (val
));
960 printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"", exp
, histindex
);
961 else if (histindex
>= 0)
962 printf_filtered ("$%d = ", histindex
);
965 annotate_value_history_value ();
967 print_formatted (val
, format
, fmt
.size
, gdb_stdout
);
968 printf_filtered ("\n");
971 annotate_value_history_end ();
973 annotate_value_end ();
976 printf_unfiltered ("\") )\030");
980 do_cleanups (old_chain
);
981 inspect_it
= 0; /* Reset print routines to normal */
986 print_command (char *exp
, int from_tty
)
988 print_command_1 (exp
, 0, 1);
991 /* Same as print, except in epoch, it gets its own window */
994 inspect_command (char *exp
, int from_tty
)
996 extern int epoch_interface
;
998 print_command_1 (exp
, epoch_interface
, 1);
1001 /* Same as print, except it doesn't print void results. */
1004 call_command (char *exp
, int from_tty
)
1006 print_command_1 (exp
, 0, 0);
1011 output_command (char *exp
, int from_tty
)
1013 struct expression
*expr
;
1014 register struct cleanup
*old_chain
;
1015 register char format
= 0;
1017 struct format_data fmt
;
1019 if (exp
&& *exp
== '/')
1022 fmt
= decode_format (&exp
, 0, 0);
1023 validate_format (fmt
, "output");
1024 format
= fmt
.format
;
1027 expr
= parse_expression (exp
);
1028 old_chain
= make_cleanup (free_current_contents
, &expr
);
1030 val
= evaluate_expression (expr
);
1032 annotate_value_begin (VALUE_TYPE (val
));
1034 print_formatted (val
, format
, fmt
.size
, gdb_stdout
);
1036 annotate_value_end ();
1039 gdb_flush (gdb_stdout
);
1041 do_cleanups (old_chain
);
1046 set_command (char *exp
, int from_tty
)
1048 struct expression
*expr
= parse_expression (exp
);
1049 register struct cleanup
*old_chain
=
1050 make_cleanup (free_current_contents
, &expr
);
1051 evaluate_expression (expr
);
1052 do_cleanups (old_chain
);
1057 sym_info (char *arg
, int from_tty
)
1059 struct minimal_symbol
*msymbol
;
1060 struct objfile
*objfile
;
1061 struct obj_section
*osect
;
1063 CORE_ADDR addr
, sect_addr
;
1065 unsigned int offset
;
1068 error_no_arg ("address");
1070 addr
= parse_and_eval_address (arg
);
1071 ALL_OBJSECTIONS (objfile
, osect
)
1073 sect
= osect
->the_bfd_section
;
1074 sect_addr
= overlay_mapped_address (addr
, sect
);
1076 if (osect
->addr
<= sect_addr
&& sect_addr
< osect
->endaddr
&&
1077 (msymbol
= lookup_minimal_symbol_by_pc_section (sect_addr
, sect
)))
1080 offset
= sect_addr
- SYMBOL_VALUE_ADDRESS (msymbol
);
1082 printf_filtered ("%s + %u in ",
1083 SYMBOL_SOURCE_NAME (msymbol
), offset
);
1085 printf_filtered ("%s in ",
1086 SYMBOL_SOURCE_NAME (msymbol
));
1087 if (pc_in_unmapped_range (addr
, sect
))
1088 printf_filtered ("load address range of ");
1089 if (section_is_overlay (sect
))
1090 printf_filtered ("%s overlay ",
1091 section_is_mapped (sect
) ? "mapped" : "unmapped");
1092 printf_filtered ("section %s", sect
->name
);
1093 printf_filtered ("\n");
1097 printf_filtered ("No symbol matches %s.\n", arg
);
1102 address_info (char *exp
, int from_tty
)
1104 register struct symbol
*sym
;
1105 register struct minimal_symbol
*msymbol
;
1107 register long basereg
;
1109 CORE_ADDR load_addr
;
1110 int is_a_field_of_this
; /* C++: lookup_symbol sets this to nonzero
1111 if exp is a field of `this'. */
1114 error ("Argument required.");
1116 sym
= lookup_symbol (exp
, get_selected_block (), VAR_NAMESPACE
,
1117 &is_a_field_of_this
, (struct symtab
**) NULL
);
1120 if (is_a_field_of_this
)
1122 printf_filtered ("Symbol \"");
1123 fprintf_symbol_filtered (gdb_stdout
, exp
,
1124 current_language
->la_language
, DMGL_ANSI
);
1125 printf_filtered ("\" is a field of the local class variable `this'\n");
1129 msymbol
= lookup_minimal_symbol (exp
, NULL
, NULL
);
1131 if (msymbol
!= NULL
)
1133 load_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1135 printf_filtered ("Symbol \"");
1136 fprintf_symbol_filtered (gdb_stdout
, exp
,
1137 current_language
->la_language
, DMGL_ANSI
);
1138 printf_filtered ("\" is at ");
1139 print_address_numeric (load_addr
, 1, gdb_stdout
);
1140 printf_filtered (" in a file compiled without debugging");
1141 section
= SYMBOL_BFD_SECTION (msymbol
);
1142 if (section_is_overlay (section
))
1144 load_addr
= overlay_unmapped_address (load_addr
, section
);
1145 printf_filtered (",\n -- loaded at ");
1146 print_address_numeric (load_addr
, 1, gdb_stdout
);
1147 printf_filtered (" in overlay section %s", section
->name
);
1149 printf_filtered (".\n");
1152 error ("No symbol \"%s\" in current context.", exp
);
1156 printf_filtered ("Symbol \"");
1157 fprintf_symbol_filtered (gdb_stdout
, SYMBOL_NAME (sym
),
1158 current_language
->la_language
, DMGL_ANSI
);
1159 printf_filtered ("\" is ");
1160 val
= SYMBOL_VALUE (sym
);
1161 basereg
= SYMBOL_BASEREG (sym
);
1162 section
= SYMBOL_BFD_SECTION (sym
);
1164 switch (SYMBOL_CLASS (sym
))
1167 case LOC_CONST_BYTES
:
1168 printf_filtered ("constant");
1172 printf_filtered ("a label at address ");
1173 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1175 if (section_is_overlay (section
))
1177 load_addr
= overlay_unmapped_address (load_addr
, section
);
1178 printf_filtered (",\n -- loaded at ");
1179 print_address_numeric (load_addr
, 1, gdb_stdout
);
1180 printf_filtered (" in overlay section %s", section
->name
);
1185 printf_filtered ("a variable in register %s", REGISTER_NAME (val
));
1189 printf_filtered ("static storage at address ");
1190 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1192 if (section_is_overlay (section
))
1194 load_addr
= overlay_unmapped_address (load_addr
, section
);
1195 printf_filtered (",\n -- loaded at ");
1196 print_address_numeric (load_addr
, 1, gdb_stdout
);
1197 printf_filtered (" in overlay section %s", section
->name
);
1202 printf_filtered ("external global (indirect addressing), at address *(");
1203 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1205 printf_filtered (")");
1206 if (section_is_overlay (section
))
1208 load_addr
= overlay_unmapped_address (load_addr
, section
);
1209 printf_filtered (",\n -- loaded at ");
1210 print_address_numeric (load_addr
, 1, gdb_stdout
);
1211 printf_filtered (" in overlay section %s", section
->name
);
1216 printf_filtered ("an argument in register %s", REGISTER_NAME (val
));
1219 case LOC_REGPARM_ADDR
:
1220 printf_filtered ("address of an argument in register %s", REGISTER_NAME (val
));
1224 printf_filtered ("an argument at offset %ld", val
);
1228 printf_filtered ("an argument at frame offset %ld", val
);
1232 printf_filtered ("a local variable at frame offset %ld", val
);
1236 printf_filtered ("a reference argument at offset %ld", val
);
1240 printf_filtered ("a variable at offset %ld from register %s",
1241 val
, REGISTER_NAME (basereg
));
1244 case LOC_BASEREG_ARG
:
1245 printf_filtered ("an argument at offset %ld from register %s",
1246 val
, REGISTER_NAME (basereg
));
1250 printf_filtered ("a typedef");
1254 printf_filtered ("a function at address ");
1255 #ifdef GDB_TARGET_MASK_DISAS_PC
1256 print_address_numeric
1257 (load_addr
= GDB_TARGET_MASK_DISAS_PC (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))),
1260 print_address_numeric (load_addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)),
1263 if (section_is_overlay (section
))
1265 load_addr
= overlay_unmapped_address (load_addr
, section
);
1266 printf_filtered (",\n -- loaded at ");
1267 print_address_numeric (load_addr
, 1, gdb_stdout
);
1268 printf_filtered (" in overlay section %s", section
->name
);
1272 case LOC_UNRESOLVED
:
1274 struct minimal_symbol
*msym
;
1276 msym
= lookup_minimal_symbol (SYMBOL_NAME (sym
), NULL
, NULL
);
1278 printf_filtered ("unresolved");
1281 section
= SYMBOL_BFD_SECTION (msym
);
1282 printf_filtered ("static storage at address ");
1283 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (msym
),
1285 if (section_is_overlay (section
))
1287 load_addr
= overlay_unmapped_address (load_addr
, section
);
1288 printf_filtered (",\n -- loaded at ");
1289 print_address_numeric (load_addr
, 1, gdb_stdout
);
1290 printf_filtered (" in overlay section %s", section
->name
);
1296 case LOC_THREAD_LOCAL_STATIC
:
1298 "a thread-local variable at offset %ld from the thread base register %s",
1299 val
, REGISTER_NAME (basereg
));
1302 case LOC_OPTIMIZED_OUT
:
1303 printf_filtered ("optimized out");
1307 printf_filtered ("of unknown (botched) type");
1310 printf_filtered (".\n");
1314 x_command (char *exp
, int from_tty
)
1316 struct expression
*expr
;
1317 struct format_data fmt
;
1318 struct cleanup
*old_chain
;
1321 fmt
.format
= last_format
;
1322 fmt
.size
= last_size
;
1325 if (exp
&& *exp
== '/')
1328 fmt
= decode_format (&exp
, last_format
, last_size
);
1331 /* If we have an expression, evaluate it and use it as the address. */
1333 if (exp
!= 0 && *exp
!= 0)
1335 expr
= parse_expression (exp
);
1336 /* Cause expression not to be there any more
1337 if this command is repeated with Newline.
1338 But don't clobber a user-defined command's definition. */
1341 old_chain
= make_cleanup (free_current_contents
, &expr
);
1342 val
= evaluate_expression (expr
);
1343 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_REF
)
1344 val
= value_ind (val
);
1345 /* In rvalue contexts, such as this, functions are coerced into
1346 pointers to functions. This makes "x/i main" work. */
1347 if (/* last_format == 'i' && */
1348 TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FUNC
1349 && VALUE_LVAL (val
) == lval_memory
)
1350 next_address
= VALUE_ADDRESS (val
);
1352 next_address
= value_as_address (val
);
1353 if (VALUE_BFD_SECTION (val
))
1354 next_section
= VALUE_BFD_SECTION (val
);
1355 do_cleanups (old_chain
);
1358 do_examine (fmt
, next_address
, next_section
);
1360 /* If the examine succeeds, we remember its size and format for next time. */
1361 last_size
= fmt
.size
;
1362 last_format
= fmt
.format
;
1364 /* Set a couple of internal variables if appropriate. */
1365 if (last_examine_value
)
1367 /* Make last address examined available to the user as $_. Use
1368 the correct pointer type. */
1369 struct type
*pointer_type
1370 = lookup_pointer_type (VALUE_TYPE (last_examine_value
));
1371 set_internalvar (lookup_internalvar ("_"),
1372 value_from_pointer (pointer_type
,
1373 last_examine_address
));
1375 /* Make contents of last address examined available to the user as $__. */
1376 /* If the last value has not been fetched from memory then don't
1377 fetch it now - instead mark it by voiding the $__ variable. */
1378 if (VALUE_LAZY (last_examine_value
))
1379 set_internalvar (lookup_internalvar ("__"),
1380 allocate_value (builtin_type_void
));
1382 set_internalvar (lookup_internalvar ("__"), last_examine_value
);
1387 /* Add an expression to the auto-display chain.
1388 Specify the expression. */
1391 display_command (char *exp
, int from_tty
)
1393 struct format_data fmt
;
1394 register struct expression
*expr
;
1395 register struct display
*new;
1399 if (tui_version
&& *exp
== '$')
1400 display_it
= (tui_set_layout (exp
) == TUI_FAILURE
);
1414 fmt
= decode_format (&exp
, 0, 0);
1415 if (fmt
.size
&& fmt
.format
== 0)
1417 if (fmt
.format
== 'i' || fmt
.format
== 's')
1427 innermost_block
= 0;
1428 expr
= parse_expression (exp
);
1430 new = (struct display
*) xmalloc (sizeof (struct display
));
1433 new->block
= innermost_block
;
1434 new->next
= display_chain
;
1435 new->number
= ++display_number
;
1438 display_chain
= new;
1440 if (from_tty
&& target_has_execution
)
1441 do_one_display (new);
1448 free_display (struct display
*d
)
1454 /* Clear out the display_chain.
1455 Done when new symtabs are loaded, since this invalidates
1456 the types stored in many expressions. */
1459 clear_displays (void)
1461 register struct display
*d
;
1463 while ((d
= display_chain
) != NULL
)
1466 display_chain
= d
->next
;
1471 /* Delete the auto-display number NUM. */
1474 delete_display (int num
)
1476 register struct display
*d1
, *d
;
1479 error ("No display number %d.", num
);
1481 if (display_chain
->number
== num
)
1484 display_chain
= d1
->next
;
1488 for (d
= display_chain
;; d
= d
->next
)
1491 error ("No display number %d.", num
);
1492 if (d
->next
->number
== num
)
1502 /* Delete some values from the auto-display chain.
1503 Specify the element numbers. */
1506 undisplay_command (char *args
, int from_tty
)
1508 register char *p
= args
;
1514 if (query ("Delete all auto-display expressions? "))
1523 while (*p1
>= '0' && *p1
<= '9')
1525 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1526 error ("Arguments must be display numbers.");
1530 delete_display (num
);
1533 while (*p
== ' ' || *p
== '\t')
1539 /* Display a single auto-display.
1540 Do nothing if the display cannot be printed in the current context,
1541 or if the display is disabled. */
1544 do_one_display (struct display
*d
)
1546 int within_current_scope
;
1548 if (d
->enabled_p
== 0)
1552 within_current_scope
= contained_in (get_selected_block (), d
->block
);
1554 within_current_scope
= 1;
1555 if (!within_current_scope
)
1558 current_display_number
= d
->number
;
1560 annotate_display_begin ();
1561 printf_filtered ("%d", d
->number
);
1562 annotate_display_number_end ();
1563 printf_filtered (": ");
1569 annotate_display_format ();
1571 printf_filtered ("x/");
1572 if (d
->format
.count
!= 1)
1573 printf_filtered ("%d", d
->format
.count
);
1574 printf_filtered ("%c", d
->format
.format
);
1575 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1576 printf_filtered ("%c", d
->format
.size
);
1577 printf_filtered (" ");
1579 annotate_display_expression ();
1581 print_expression (d
->exp
, gdb_stdout
);
1582 annotate_display_expression_end ();
1584 if (d
->format
.count
!= 1)
1585 printf_filtered ("\n");
1587 printf_filtered (" ");
1589 val
= evaluate_expression (d
->exp
);
1590 addr
= value_as_address (val
);
1591 if (d
->format
.format
== 'i')
1592 addr
= ADDR_BITS_REMOVE (addr
);
1594 annotate_display_value ();
1596 do_examine (d
->format
, addr
, VALUE_BFD_SECTION (val
));
1600 annotate_display_format ();
1602 if (d
->format
.format
)
1603 printf_filtered ("/%c ", d
->format
.format
);
1605 annotate_display_expression ();
1607 print_expression (d
->exp
, gdb_stdout
);
1608 annotate_display_expression_end ();
1610 printf_filtered (" = ");
1612 annotate_display_expression ();
1614 print_formatted (evaluate_expression (d
->exp
),
1615 d
->format
.format
, d
->format
.size
, gdb_stdout
);
1616 printf_filtered ("\n");
1619 annotate_display_end ();
1621 gdb_flush (gdb_stdout
);
1622 current_display_number
= -1;
1625 /* Display all of the values on the auto-display chain which can be
1626 evaluated in the current scope. */
1631 register struct display
*d
;
1633 for (d
= display_chain
; d
; d
= d
->next
)
1637 /* Delete the auto-display which we were in the process of displaying.
1638 This is done when there is an error or a signal. */
1641 disable_display (int num
)
1643 register struct display
*d
;
1645 for (d
= display_chain
; d
; d
= d
->next
)
1646 if (d
->number
== num
)
1651 printf_unfiltered ("No display number %d.\n", num
);
1655 disable_current_display (void)
1657 if (current_display_number
>= 0)
1659 disable_display (current_display_number
);
1660 fprintf_unfiltered (gdb_stderr
, "Disabling display %d to avoid infinite recursion.\n",
1661 current_display_number
);
1663 current_display_number
= -1;
1667 display_info (char *ignore
, int from_tty
)
1669 register struct display
*d
;
1672 printf_unfiltered ("There are no auto-display expressions now.\n");
1674 printf_filtered ("Auto-display expressions now in effect:\n\
1675 Num Enb Expression\n");
1677 for (d
= display_chain
; d
; d
= d
->next
)
1679 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
1681 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
1683 else if (d
->format
.format
)
1684 printf_filtered ("/%c ", d
->format
.format
);
1685 print_expression (d
->exp
, gdb_stdout
);
1686 if (d
->block
&& !contained_in (get_selected_block (), d
->block
))
1687 printf_filtered (" (cannot be evaluated in the current context)");
1688 printf_filtered ("\n");
1689 gdb_flush (gdb_stdout
);
1694 enable_display (char *args
, int from_tty
)
1696 register char *p
= args
;
1699 register struct display
*d
;
1703 for (d
= display_chain
; d
; d
= d
->next
)
1710 while (*p1
>= '0' && *p1
<= '9')
1712 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1713 error ("Arguments must be display numbers.");
1717 for (d
= display_chain
; d
; d
= d
->next
)
1718 if (d
->number
== num
)
1723 printf_unfiltered ("No display number %d.\n", num
);
1726 while (*p
== ' ' || *p
== '\t')
1733 disable_display_command (char *args
, int from_tty
)
1735 register char *p
= args
;
1737 register struct display
*d
;
1741 for (d
= display_chain
; d
; d
= d
->next
)
1748 while (*p1
>= '0' && *p1
<= '9')
1750 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1751 error ("Arguments must be display numbers.");
1753 disable_display (atoi (p
));
1756 while (*p
== ' ' || *p
== '\t')
1762 /* Print the value in stack frame FRAME of a variable
1763 specified by a struct symbol. */
1766 print_variable_value (struct symbol
*var
, struct frame_info
*frame
,
1767 struct ui_file
*stream
)
1769 struct value
*val
= read_var_value (var
, frame
);
1771 value_print (val
, stream
, 0, Val_pretty_default
);
1774 /* Print the arguments of a stack frame, given the function FUNC
1775 running in that frame (as a symbol), the info on the frame,
1776 and the number of args according to the stack frame (or -1 if unknown). */
1778 /* References here and elsewhere to "number of args according to the
1779 stack frame" appear in all cases to refer to "number of ints of args
1780 according to the stack frame". At least for VAX, i386, isi. */
1783 print_frame_args (struct symbol
*func
, struct frame_info
*fi
, int num
,
1784 struct ui_file
*stream
)
1786 struct block
*b
= NULL
;
1789 register struct symbol
*sym
;
1791 /* Offset of next stack argument beyond the one we have seen that is
1792 at the highest offset.
1793 -1 if we haven't come to a stack argument yet. */
1794 long highest_offset
= -1;
1796 /* Number of ints of arguments that we have printed so far. */
1797 int args_printed
= 0;
1798 struct cleanup
*old_chain
, *list_chain
;
1799 struct ui_stream
*stb
;
1801 stb
= ui_out_stream_new (uiout
);
1802 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1806 b
= SYMBOL_BLOCK_VALUE (func
);
1807 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
1811 /* Keep track of the highest stack argument offset seen, and
1812 skip over any kinds of symbols we don't care about. */
1814 switch (SYMBOL_CLASS (sym
))
1819 long current_offset
= SYMBOL_VALUE (sym
);
1820 arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
1822 /* Compute address of next argument by adding the size of
1823 this argument and rounding to an int boundary. */
1825 ((current_offset
+ arg_size
+ sizeof (int) - 1)
1826 & ~(sizeof (int) - 1));
1828 /* If this is the highest offset seen yet, set highest_offset. */
1829 if (highest_offset
== -1
1830 || (current_offset
> highest_offset
))
1831 highest_offset
= current_offset
;
1833 /* Add the number of ints we're about to print to args_printed. */
1834 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
1837 /* We care about types of symbols, but don't need to keep track of
1838 stack offsets in them. */
1840 case LOC_REGPARM_ADDR
:
1842 case LOC_BASEREG_ARG
:
1845 /* Other types of symbols we just skip over. */
1850 /* We have to look up the symbol because arguments can have
1851 two entries (one a parameter, one a local) and the one we
1852 want is the local, which lookup_symbol will find for us.
1853 This includes gcc1 (not gcc2) on the sparc when passing a
1854 small structure and gcc2 when the argument type is float
1855 and it is passed as a double and converted to float by
1856 the prologue (in the latter case the type of the LOC_ARG
1857 symbol is double and the type of the LOC_LOCAL symbol is
1859 /* But if the parameter name is null, don't try it.
1860 Null parameter names occur on the RS/6000, for traceback tables.
1861 FIXME, should we even print them? */
1863 if (*SYMBOL_NAME (sym
))
1865 struct symbol
*nsym
;
1866 nsym
= lookup_symbol
1868 b
, VAR_NAMESPACE
, (int *) NULL
, (struct symtab
**) NULL
);
1869 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
)
1871 /* There is a LOC_ARG/LOC_REGISTER pair. This means that
1872 it was passed on the stack and loaded into a register,
1873 or passed in a register and stored in a stack slot.
1874 GDB 3.x used the LOC_ARG; GDB 4.0-4.11 used the LOC_REGISTER.
1876 Reasons for using the LOC_ARG:
1877 (1) because find_saved_registers may be slow for remote
1879 (2) because registers are often re-used and stack slots
1880 rarely (never?) are. Therefore using the stack slot is
1881 much less likely to print garbage.
1883 Reasons why we might want to use the LOC_REGISTER:
1884 (1) So that the backtrace prints the same value as
1885 "print foo". I see no compelling reason why this needs
1886 to be the case; having the backtrace print the value which
1887 was passed in, and "print foo" print the value as modified
1888 within the called function, makes perfect sense to me.
1890 Additional note: It might be nice if "info args" displayed
1892 One more note: There is a case with sparc structure passing
1893 where we need to use the LOC_REGISTER, but this is dealt with
1894 by creating a single LOC_REGPARM in symbol reading. */
1896 /* Leave sym (the LOC_ARG) alone. */
1903 /* Print the current arg. */
1905 ui_out_text (uiout
, ", ");
1906 ui_out_wrap_hint (uiout
, " ");
1908 annotate_arg_begin ();
1910 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1911 fprintf_symbol_filtered (stb
->stream
, SYMBOL_SOURCE_NAME (sym
),
1912 SYMBOL_LANGUAGE (sym
), DMGL_PARAMS
| DMGL_ANSI
);
1913 ui_out_field_stream (uiout
, "name", stb
);
1914 annotate_arg_name_end ();
1915 ui_out_text (uiout
, "=");
1917 /* Avoid value_print because it will deref ref parameters. We just
1918 want to print their addresses. Print ??? for args whose address
1919 we do not know. We pass 2 as "recurse" to val_print because our
1920 standard indentation here is 4 spaces, and val_print indents
1921 2 for each recurse. */
1922 val
= read_var_value (sym
, fi
);
1924 annotate_arg_value (val
== NULL
? NULL
: VALUE_TYPE (val
));
1928 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
), 0,
1929 VALUE_ADDRESS (val
),
1930 stb
->stream
, 0, 0, 2, Val_no_prettyprint
);
1931 ui_out_field_stream (uiout
, "value", stb
);
1934 ui_out_text (uiout
, "???");
1936 /* Invoke ui_out_tuple_end. */
1937 do_cleanups (list_chain
);
1939 annotate_arg_end ();
1945 /* Don't print nameless args in situations where we don't know
1946 enough about the stack to find them. */
1951 if (highest_offset
== -1)
1952 start
= FRAME_ARGS_SKIP
;
1954 start
= highest_offset
;
1956 print_frame_nameless_args (fi
, start
, num
- args_printed
,
1959 do_cleanups (old_chain
);
1962 /* Print nameless args on STREAM.
1963 FI is the frameinfo for this frame, START is the offset
1964 of the first nameless arg, and NUM is the number of nameless args to
1965 print. FIRST is nonzero if this is the first argument (not just
1966 the first nameless arg). */
1969 print_frame_nameless_args (struct frame_info
*fi
, long start
, int num
,
1970 int first
, struct ui_file
*stream
)
1976 for (i
= 0; i
< num
; i
++)
1979 #ifdef NAMELESS_ARG_VALUE
1980 NAMELESS_ARG_VALUE (fi
, start
, &arg_value
);
1982 argsaddr
= FRAME_ARGS_ADDRESS (fi
);
1986 arg_value
= read_memory_integer (argsaddr
+ start
, sizeof (int));
1990 fprintf_filtered (stream
, ", ");
1992 #ifdef PRINT_NAMELESS_INTEGER
1993 PRINT_NAMELESS_INTEGER (stream
, arg_value
);
1995 #ifdef PRINT_TYPELESS_INTEGER
1996 PRINT_TYPELESS_INTEGER (stream
, builtin_type_int
, (LONGEST
) arg_value
);
1998 fprintf_filtered (stream
, "%ld", arg_value
);
1999 #endif /* PRINT_TYPELESS_INTEGER */
2000 #endif /* PRINT_NAMELESS_INTEGER */
2002 start
+= sizeof (int);
2008 printf_command (char *arg
, int from_tty
)
2010 register char *f
= NULL
;
2011 register char *s
= arg
;
2012 char *string
= NULL
;
2013 struct value
**val_args
;
2015 char *current_substring
;
2017 int allocated_args
= 20;
2018 struct cleanup
*old_cleanups
;
2020 val_args
= (struct value
**) xmalloc (allocated_args
2021 * sizeof (struct value
*));
2022 old_cleanups
= make_cleanup (free_current_contents
, &val_args
);
2025 error_no_arg ("format-control string and values to print");
2027 /* Skip white space before format string */
2028 while (*s
== ' ' || *s
== '\t')
2031 /* A format string should follow, enveloped in double quotes */
2033 error ("Bad format string, missing '\"'.");
2035 /* Parse the format-control string and copy it into the string STRING,
2036 processing some kinds of escape sequence. */
2038 f
= string
= (char *) alloca (strlen (s
) + 1);
2046 error ("Bad format string, non-terminated '\"'.");
2079 /* ??? TODO: handle other escape sequences */
2080 error ("Unrecognized escape character \\%c in format string.",
2090 /* Skip over " and following space and comma. */
2093 while (*s
== ' ' || *s
== '\t')
2096 if (*s
!= ',' && *s
!= 0)
2097 error ("Invalid argument syntax");
2101 while (*s
== ' ' || *s
== '\t')
2104 /* Need extra space for the '\0's. Doubling the size is sufficient. */
2105 substrings
= alloca (strlen (string
) * 2);
2106 current_substring
= substrings
;
2109 /* Now scan the string for %-specs and see what kinds of args they want.
2110 argclass[I] classifies the %-specs so we can give printf_filtered
2111 something of the right size. */
2115 no_arg
, int_arg
, string_arg
, double_arg
, long_long_arg
2117 enum argclass
*argclass
;
2118 enum argclass this_argclass
;
2124 argclass
= (enum argclass
*) alloca (strlen (s
) * sizeof *argclass
);
2132 while (strchr ("0123456789.hlL-+ #", *f
))
2134 if (*f
== 'l' || *f
== 'L')
2141 this_argclass
= string_arg
;
2147 this_argclass
= double_arg
;
2151 error ("`*' not supported for precision or width in printf");
2154 error ("Format specifier `n' not supported in printf");
2157 this_argclass
= no_arg
;
2162 this_argclass
= long_long_arg
;
2164 this_argclass
= int_arg
;
2168 if (this_argclass
!= no_arg
)
2170 strncpy (current_substring
, last_arg
, f
- last_arg
);
2171 current_substring
+= f
- last_arg
;
2172 *current_substring
++ = '\0';
2174 argclass
[nargs_wanted
++] = this_argclass
;
2178 /* Now, parse all arguments and evaluate them.
2179 Store the VALUEs in VAL_ARGS. */
2184 if (nargs
== allocated_args
)
2185 val_args
= (struct value
**) xrealloc ((char *) val_args
,
2186 (allocated_args
*= 2)
2187 * sizeof (struct value
*));
2189 val_args
[nargs
] = parse_to_comma_and_eval (&s1
);
2191 /* If format string wants a float, unchecked-convert the value to
2192 floating point of the same size */
2194 if (argclass
[nargs
] == double_arg
)
2196 struct type
*type
= VALUE_TYPE (val_args
[nargs
]);
2197 if (TYPE_LENGTH (type
) == sizeof (float))
2198 VALUE_TYPE (val_args
[nargs
]) = builtin_type_float
;
2199 if (TYPE_LENGTH (type
) == sizeof (double))
2200 VALUE_TYPE (val_args
[nargs
]) = builtin_type_double
;
2208 if (nargs
!= nargs_wanted
)
2209 error ("Wrong number of arguments for specified format-string");
2211 /* Now actually print them. */
2212 current_substring
= substrings
;
2213 for (i
= 0; i
< nargs
; i
++)
2215 switch (argclass
[i
])
2222 tem
= value_as_address (val_args
[i
]);
2224 /* This is a %s argument. Find the length of the string. */
2229 read_memory (tem
+ j
, &c
, 1);
2234 /* Copy the string contents into a string inside GDB. */
2235 str
= (char *) alloca (j
+ 1);
2237 read_memory (tem
, str
, j
);
2240 printf_filtered (current_substring
, str
);
2245 double val
= value_as_double (val_args
[i
]);
2246 printf_filtered (current_substring
, val
);
2250 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2252 long long val
= value_as_long (val_args
[i
]);
2253 printf_filtered (current_substring
, val
);
2257 error ("long long not supported in printf");
2261 /* FIXME: there should be separate int_arg and long_arg. */
2262 long val
= value_as_long (val_args
[i
]);
2263 printf_filtered (current_substring
, val
);
2266 default: /* purecov: deadcode */
2267 error ("internal error in printf_command"); /* purecov: deadcode */
2269 /* Skip to the next substring. */
2270 current_substring
+= strlen (current_substring
) + 1;
2272 /* Print the portion of the format string after the last argument. */
2273 printf_filtered (last_arg
);
2275 do_cleanups (old_cleanups
);
2278 /* Dump a specified section of assembly code. With no command line
2279 arguments, this command will dump the assembly code for the
2280 function surrounding the pc value in the selected frame. With one
2281 argument, it will dump the assembly code surrounding that pc value.
2282 Two arguments are interpeted as bounds within which to dump
2287 disassemble_command (char *arg
, int from_tty
)
2289 CORE_ADDR low
, high
;
2291 CORE_ADDR pc
, pc_masked
;
2300 if (!selected_frame
)
2301 error ("No frame selected.\n");
2303 pc
= get_frame_pc (selected_frame
);
2304 if (find_pc_partial_function (pc
, &name
, &low
, &high
) == 0)
2305 error ("No function contains program counter for selected frame.\n");
2307 else if (tui_version
)
2308 low
= tuiGetLowDisassemblyAddress (low
, pc
);
2310 low
+= FUNCTION_START_OFFSET
;
2312 else if (!(space_index
= (char *) strchr (arg
, ' ')))
2315 pc
= parse_and_eval_address (arg
);
2316 if (find_pc_partial_function (pc
, &name
, &low
, &high
) == 0)
2317 error ("No function contains specified address.\n");
2319 else if (tui_version
)
2320 low
= tuiGetLowDisassemblyAddress (low
, pc
);
2323 if (overlay_debugging
)
2325 section
= find_pc_overlay (pc
);
2326 if (pc_in_unmapped_range (pc
, section
))
2328 /* find_pc_partial_function will have returned low and high
2329 relative to the symbolic (mapped) address range. Need to
2330 translate them back to the unmapped range where PC is. */
2331 low
= overlay_unmapped_address (low
, section
);
2332 high
= overlay_unmapped_address (high
, section
);
2336 low
+= FUNCTION_START_OFFSET
;
2340 /* Two arguments. */
2341 *space_index
= '\0';
2342 low
= parse_and_eval_address (arg
);
2343 high
= parse_and_eval_address (space_index
+ 1);
2347 if (!tui_is_window_visible (DISASSEM_WIN
))
2350 printf_filtered ("Dump of assembler code ");
2353 printf_filtered ("for function %s:\n", name
);
2357 printf_filtered ("from ");
2358 print_address_numeric (low
, 1, gdb_stdout
);
2359 printf_filtered (" to ");
2360 print_address_numeric (high
, 1, gdb_stdout
);
2361 printf_filtered (":\n");
2364 /* Dump the specified range. */
2367 #ifdef GDB_TARGET_MASK_DISAS_PC
2368 pc_masked
= GDB_TARGET_MASK_DISAS_PC (pc
);
2373 while (pc_masked
< high
)
2376 print_address (pc_masked
, gdb_stdout
);
2377 printf_filtered (":\t");
2378 /* We often wrap here if there are long symbolic names. */
2380 pc
+= print_insn (pc
, gdb_stdout
);
2381 printf_filtered ("\n");
2383 #ifdef GDB_TARGET_MASK_DISAS_PC
2384 pc_masked
= GDB_TARGET_MASK_DISAS_PC (pc
);
2389 printf_filtered ("End of assembler dump.\n");
2390 gdb_flush (gdb_stdout
);
2395 tui_show_assembly (low
);
2400 /* Print the instruction at address MEMADDR in debugged memory,
2401 on STREAM. Returns length of the instruction, in bytes. */
2404 print_insn (CORE_ADDR memaddr
, struct ui_file
*stream
)
2406 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
2407 TARGET_PRINT_INSN_INFO
->endian
= BFD_ENDIAN_BIG
;
2409 TARGET_PRINT_INSN_INFO
->endian
= BFD_ENDIAN_LITTLE
;
2411 if (TARGET_ARCHITECTURE
!= NULL
)
2412 TARGET_PRINT_INSN_INFO
->mach
= TARGET_ARCHITECTURE
->mach
;
2413 /* else: should set .mach=0 but some disassemblers don't grok this */
2415 TARGET_PRINT_INSN_INFO
->stream
= stream
;
2417 return TARGET_PRINT_INSN (memaddr
, TARGET_PRINT_INSN_INFO
);
2422 _initialize_printcmd (void)
2424 struct cmd_list_element
*c
;
2426 current_display_number
= -1;
2428 add_info ("address", address_info
,
2429 "Describe where symbol SYM is stored.");
2431 add_info ("symbol", sym_info
,
2432 "Describe what symbol is at location ADDR.\n\
2433 Only for symbols with fixed locations (global or static scope).");
2435 add_com ("x", class_vars
, x_command
,
2436 concat ("Examine memory: x/FMT ADDRESS.\n\
2437 ADDRESS is an expression for the memory address to examine.\n\
2438 FMT is a repeat count followed by a format letter and a size letter.\n\
2439 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2440 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n",
2441 "Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2442 The specified number of objects of the specified size are printed\n\
2443 according to the format.\n\n\
2444 Defaults for format and size letters are those previously used.\n\
2445 Default count is 1. Default address is following last thing printed\n\
2446 with this command or \"print\".", NULL
));
2448 c
= add_com ("disassemble", class_vars
, disassemble_command
,
2449 "Disassemble a specified section of memory.\n\
2450 Default is the function surrounding the pc of the selected frame.\n\
2451 With a single argument, the function surrounding that address is dumped.\n\
2452 Two arguments are taken as a range of memory to dump.");
2453 c
->completer
= location_completer
;
2455 add_com_alias ("va", "disassemble", class_xdb
, 0);
2458 add_com ("whereis", class_vars
, whereis_command
,
2459 "Print line number and file of definition of variable.");
2462 add_info ("display", display_info
,
2463 "Expressions to display when program stops, with code numbers.");
2465 add_cmd ("undisplay", class_vars
, undisplay_command
,
2466 "Cancel some expressions to be displayed when program stops.\n\
2467 Arguments are the code numbers of the expressions to stop displaying.\n\
2468 No argument means cancel all automatic-display expressions.\n\
2469 \"delete display\" has the same effect as this command.\n\
2470 Do \"info display\" to see current list of code numbers.",
2473 add_com ("display", class_vars
, display_command
,
2474 "Print value of expression EXP each time the program stops.\n\
2475 /FMT may be used before EXP as in the \"print\" command.\n\
2476 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2477 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2478 and examining is done as in the \"x\" command.\n\n\
2479 With no argument, display all currently requested auto-display expressions.\n\
2480 Use \"undisplay\" to cancel display requests previously made."
2483 add_cmd ("display", class_vars
, enable_display
,
2484 "Enable some expressions to be displayed when program stops.\n\
2485 Arguments are the code numbers of the expressions to resume displaying.\n\
2486 No argument means enable all automatic-display expressions.\n\
2487 Do \"info display\" to see current list of code numbers.", &enablelist
);
2489 add_cmd ("display", class_vars
, disable_display_command
,
2490 "Disable some expressions to be displayed when program stops.\n\
2491 Arguments are the code numbers of the expressions to stop displaying.\n\
2492 No argument means disable all automatic-display expressions.\n\
2493 Do \"info display\" to see current list of code numbers.", &disablelist
);
2495 add_cmd ("display", class_vars
, undisplay_command
,
2496 "Cancel some expressions to be displayed when program stops.\n\
2497 Arguments are the code numbers of the expressions to stop displaying.\n\
2498 No argument means cancel all automatic-display expressions.\n\
2499 Do \"info display\" to see current list of code numbers.", &deletelist
);
2501 add_com ("printf", class_vars
, printf_command
,
2502 "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2503 This is useful for formatted output in user-defined commands.");
2505 add_com ("output", class_vars
, output_command
,
2506 "Like \"print\" but don't put in value history and don't print newline.\n\
2507 This is useful in user-defined commands.");
2509 add_prefix_cmd ("set", class_vars
, set_command
,
2510 concat ("Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2511 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2512 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2513 with $), a register (a few standard names starting with $), or an actual\n\
2514 variable in the program being debugged. EXP is any valid expression.\n",
2515 "Use \"set variable\" for variables with names identical to set subcommands.\n\
2516 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2517 You can see these environment settings with the \"show\" command.", NULL
),
2518 &setlist
, "set ", 1, &cmdlist
);
2520 add_com ("assign", class_vars
, set_command
, concat ("Evaluate expression \
2521 EXP and assign result to variable VAR, using assignment\n\
2522 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2523 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2524 with $), a register (a few standard names starting with $), or an actual\n\
2525 variable in the program being debugged. EXP is any valid expression.\n",
2526 "Use \"set variable\" for variables with names identical to set subcommands.\n\
2527 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2528 You can see these environment settings with the \"show\" command.", NULL
));
2530 /* "call" is the same as "set", but handy for dbx users to call fns. */
2531 c
= add_com ("call", class_vars
, call_command
,
2532 "Call a function in the program.\n\
2533 The argument is the function name and arguments, in the notation of the\n\
2534 current working language. The result is printed and saved in the value\n\
2535 history, if it is not void.");
2536 c
->completer
= location_completer
;
2538 add_cmd ("variable", class_vars
, set_command
,
2539 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2540 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2541 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2542 with $), a register (a few standard names starting with $), or an actual\n\
2543 variable in the program being debugged. EXP is any valid expression.\n\
2544 This may usually be abbreviated to simply \"set\".",
2547 c
= add_com ("print", class_vars
, print_command
,
2548 concat ("Print value of expression EXP.\n\
2549 Variables accessible are those of the lexical environment of the selected\n\
2550 stack frame, plus all those whose scope is global or an entire file.\n\
2552 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2553 $$NUM refers to NUM'th value back from the last one.\n\
2554 Names starting with $ refer to registers (with the values they would have\n",
2555 "if the program were to return to the stack frame now selected, restoring\n\
2556 all registers saved by frames farther in) or else to debugger\n\
2557 \"convenience\" variables (any such name not a known register).\n\
2558 Use assignment expressions to give values to convenience variables.\n",
2560 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2561 @ is a binary operator for treating consecutive data objects\n\
2562 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2563 element is FOO, whose second element is stored in the space following\n\
2564 where FOO is stored, etc. FOO must be an expression whose value\n\
2565 resides in memory.\n",
2567 EXP may be preceded with /FMT, where FMT is a format letter\n\
2568 but no count or size letter (see \"x\" command).", NULL
));
2569 c
->completer
= location_completer
;
2570 add_com_alias ("p", "print", class_vars
, 1);
2572 c
= add_com ("inspect", class_vars
, inspect_command
,
2573 "Same as \"print\" command, except that if you are running in the epoch\n\
2574 environment, the value is printed in its own window.");
2575 c
->completer
= location_completer
;
2578 add_set_cmd ("max-symbolic-offset", no_class
, var_uinteger
,
2579 (char *) &max_symbolic_offset
,
2580 "Set the largest offset that will be printed in <symbol+1234> form.",
2584 add_set_cmd ("symbol-filename", no_class
, var_boolean
,
2585 (char *) &print_symbol_filename
,
2586 "Set printing of source filename and line number with <symbol>.",
2590 /* For examine/instruction a single byte quantity is specified as
2591 the data. This avoids problems with value_at_lazy() requiring a
2592 valid data type (and rejecting VOID). */
2593 examine_i_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_i_type", NULL
);
2595 examine_b_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_b_type", NULL
);
2596 examine_h_type
= init_type (TYPE_CODE_INT
, 2, 0, "examine_h_type", NULL
);
2597 examine_w_type
= init_type (TYPE_CODE_INT
, 4, 0, "examine_w_type", NULL
);
2598 examine_g_type
= init_type (TYPE_CODE_INT
, 8, 0, "examine_g_type", NULL
);