1 /* Print values for GNU debugger GDB.
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdb_string.h"
27 #include "expression.h"
31 #include "breakpoint.h"
33 #include "gdb-demangle.h"
36 #include "symfile.h" /* for overlay functions */
37 #include "objfiles.h" /* ditto */
38 #include "completer.h" /* for completion functions */
40 #include "gdb_assert.h"
45 #include "exceptions.h"
48 #include "parser-defs.h"
50 #include "arch-utils.h"
51 #include "cli/cli-utils.h"
55 #include "tui/tui.h" /* For tui_active et al. */
64 /* True if the value should be printed raw -- that is, bypassing
65 python-based formatters. */
69 /* Last specified output format. */
71 static char last_format
= 0;
73 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
75 static char last_size
= 'w';
77 /* Default address to examine next, and associated architecture. */
79 static struct gdbarch
*next_gdbarch
;
80 static CORE_ADDR next_address
;
82 /* Number of delay instructions following current disassembled insn. */
84 static int branch_delay_insns
;
86 /* Last address examined. */
88 static CORE_ADDR last_examine_address
;
90 /* Contents of last address examined.
91 This is not valid past the end of the `x' command! */
93 static struct value
*last_examine_value
;
95 /* Largest offset between a symbolic value and an address, that will be
96 printed as `0x1234 <symbol+offset>'. */
98 static unsigned int max_symbolic_offset
= UINT_MAX
;
100 show_max_symbolic_offset (struct ui_file
*file
, int from_tty
,
101 struct cmd_list_element
*c
, const char *value
)
103 fprintf_filtered (file
,
104 _("The largest offset that will be "
105 "printed in <symbol+1234> form is %s.\n"),
109 /* Append the source filename and linenumber of the symbol when
110 printing a symbolic value as `<symbol at filename:linenum>' if set. */
111 static int print_symbol_filename
= 0;
113 show_print_symbol_filename (struct ui_file
*file
, int from_tty
,
114 struct cmd_list_element
*c
, const char *value
)
116 fprintf_filtered (file
, _("Printing of source filename and "
117 "line number with <symbol> is %s.\n"),
121 /* Number of auto-display expression currently being displayed.
122 So that we can disable it if we get a signal within it.
123 -1 when not doing one. */
125 int current_display_number
;
129 /* Chain link to next auto-display item. */
130 struct display
*next
;
132 /* The expression as the user typed it. */
135 /* Expression to be evaluated and displayed. */
136 struct expression
*exp
;
138 /* Item number of this auto-display item. */
141 /* Display format specified. */
142 struct format_data format
;
144 /* Program space associated with `block'. */
145 struct program_space
*pspace
;
147 /* Innermost block required by this expression when evaluated. */
148 const struct block
*block
;
150 /* Status of this display (enabled or disabled). */
154 /* Chain of expressions whose values should be displayed
155 automatically each time the program stops. */
157 static struct display
*display_chain
;
159 static int display_number
;
161 /* Walk the following statement or block through all displays.
162 ALL_DISPLAYS_SAFE does so even if the statement deletes the current
165 #define ALL_DISPLAYS(B) \
166 for (B = display_chain; B; B = B->next)
168 #define ALL_DISPLAYS_SAFE(B,TMP) \
169 for (B = display_chain; \
170 B ? (TMP = B->next, 1): 0; \
173 /* Prototypes for exported functions. */
175 void output_command (char *, int);
177 void _initialize_printcmd (void);
179 /* Prototypes for local functions. */
181 static void do_one_display (struct display
*);
184 /* Decode a format specification. *STRING_PTR should point to it.
185 OFORMAT and OSIZE are used as defaults for the format and size
186 if none are given in the format specification.
187 If OSIZE is zero, then the size field of the returned value
188 should be set only if a size is explicitly specified by the
190 The structure returned describes all the data
191 found in the specification. In addition, *STRING_PTR is advanced
192 past the specification and past all whitespace following it. */
194 static struct format_data
195 decode_format (char **string_ptr
, int oformat
, int osize
)
197 struct format_data val
;
198 char *p
= *string_ptr
;
205 if (*p
>= '0' && *p
<= '9')
206 val
.count
= atoi (p
);
207 while (*p
>= '0' && *p
<= '9')
210 /* Now process size or format letters that follow. */
214 if (*p
== 'b' || *p
== 'h' || *p
== 'w' || *p
== 'g')
221 else if (*p
>= 'a' && *p
<= 'z')
227 while (*p
== ' ' || *p
== '\t')
231 /* Set defaults for format and size if not specified. */
232 if (val
.format
== '?')
236 /* Neither has been specified. */
237 val
.format
= oformat
;
241 /* If a size is specified, any format makes a reasonable
242 default except 'i'. */
243 val
.format
= oformat
== 'i' ? 'x' : oformat
;
245 else if (val
.size
== '?')
249 /* Pick the appropriate size for an address. This is deferred
250 until do_examine when we know the actual architecture to use.
251 A special size value of 'a' is used to indicate this case. */
252 val
.size
= osize
? 'a' : osize
;
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 /* Display strings with byte size chars unless explicitly
274 /* The default is the size most recently specified. */
281 /* Print value VAL on stream according to OPTIONS.
282 Do not end with a newline.
283 SIZE is the letter for the size of datum being printed.
284 This is used to pad hex numbers so they line up. SIZE is 0
285 for print / output and set for examine. */
288 print_formatted (struct value
*val
, int size
,
289 const struct value_print_options
*options
,
290 struct ui_file
*stream
)
292 struct type
*type
= check_typedef (value_type (val
));
293 int len
= TYPE_LENGTH (type
);
295 if (VALUE_LVAL (val
) == lval_memory
)
296 next_address
= value_address (val
) + len
;
300 switch (options
->format
)
304 struct type
*elttype
= value_type (val
);
306 next_address
= (value_address (val
)
307 + val_print_string (elttype
, NULL
,
308 value_address (val
), -1,
309 stream
, options
) * len
);
314 /* We often wrap here if there are long symbolic names. */
316 next_address
= (value_address (val
)
317 + gdb_print_insn (get_type_arch (type
),
318 value_address (val
), stream
,
319 &branch_delay_insns
));
324 if (options
->format
== 0 || options
->format
== 's'
325 || TYPE_CODE (type
) == TYPE_CODE_REF
326 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
327 || TYPE_CODE (type
) == TYPE_CODE_STRING
328 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
329 || TYPE_CODE (type
) == TYPE_CODE_UNION
330 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
331 value_print (val
, stream
, options
);
333 /* User specified format, so don't look to the type to tell us
335 val_print_scalar_formatted (type
,
336 value_contents_for_printing (val
),
337 value_embedded_offset (val
),
339 options
, size
, stream
);
342 /* Return builtin floating point type of same length as TYPE.
343 If no such type is found, return TYPE itself. */
345 float_type_from_length (struct type
*type
)
347 struct gdbarch
*gdbarch
= get_type_arch (type
);
348 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
350 if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_float
))
351 type
= builtin
->builtin_float
;
352 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_double
))
353 type
= builtin
->builtin_double
;
354 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_long_double
))
355 type
= builtin
->builtin_long_double
;
360 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
361 according to OPTIONS and SIZE on STREAM. Formats s and i are not
362 supported at this level. */
365 print_scalar_formatted (const void *valaddr
, struct type
*type
,
366 const struct value_print_options
*options
,
367 int size
, struct ui_file
*stream
)
369 struct gdbarch
*gdbarch
= get_type_arch (type
);
370 LONGEST val_long
= 0;
371 unsigned int len
= TYPE_LENGTH (type
);
372 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
374 /* String printing should go through val_print_scalar_formatted. */
375 gdb_assert (options
->format
!= 's');
377 if (len
> sizeof(LONGEST
) &&
378 (TYPE_CODE (type
) == TYPE_CODE_INT
379 || TYPE_CODE (type
) == TYPE_CODE_ENUM
))
381 switch (options
->format
)
384 print_octal_chars (stream
, valaddr
, len
, byte_order
);
388 print_decimal_chars (stream
, valaddr
, len
, byte_order
);
391 print_binary_chars (stream
, valaddr
, len
, byte_order
);
394 print_hex_chars (stream
, valaddr
, len
, byte_order
);
397 print_char_chars (stream
, type
, valaddr
, len
, byte_order
);
404 if (options
->format
!= 'f')
405 val_long
= unpack_long (type
, valaddr
);
407 /* If the value is a pointer, and pointers and addresses are not the
408 same, then at this point, the value's length (in target bytes) is
409 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
410 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
411 len
= gdbarch_addr_bit (gdbarch
) / TARGET_CHAR_BIT
;
413 /* If we are printing it as unsigned, truncate it in case it is actually
414 a negative signed value (e.g. "print/u (short)-1" should print 65535
415 (if shorts are 16 bits) instead of 4294967295). */
416 if (options
->format
!= 'd' || TYPE_UNSIGNED (type
))
418 if (len
< sizeof (LONGEST
))
419 val_long
&= ((LONGEST
) 1 << HOST_CHAR_BIT
* len
) - 1;
422 switch (options
->format
)
427 /* No size specified, like in print. Print varying # of digits. */
428 print_longest (stream
, 'x', 1, val_long
);
437 print_longest (stream
, size
, 1, val_long
);
440 error (_("Undefined output size \"%c\"."), size
);
445 print_longest (stream
, 'd', 1, val_long
);
449 print_longest (stream
, 'u', 0, val_long
);
454 print_longest (stream
, 'o', 1, val_long
);
456 fprintf_filtered (stream
, "0");
461 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
463 print_address (gdbarch
, addr
, stream
);
469 struct value_print_options opts
= *options
;
472 if (TYPE_UNSIGNED (type
))
473 type
= builtin_type (gdbarch
)->builtin_true_unsigned_char
;
475 type
= builtin_type (gdbarch
)->builtin_true_char
;
477 value_print (value_from_longest (type
, val_long
), stream
, &opts
);
482 type
= float_type_from_length (type
);
483 print_floating (valaddr
, type
, stream
);
487 internal_error (__FILE__
, __LINE__
,
488 _("failed internal consistency check"));
491 /* Binary; 't' stands for "two". */
493 char bits
[8 * (sizeof val_long
) + 1];
494 char buf
[8 * (sizeof val_long
) + 32];
499 width
= 8 * (sizeof val_long
);
516 error (_("Undefined output size \"%c\"."), size
);
522 bits
[width
] = (val_long
& 1) ? '1' : '0';
527 while (*cp
&& *cp
== '0')
532 strncpy (buf
, cp
, sizeof (bits
));
533 fputs_filtered (buf
, stream
);
538 error (_("Undefined output format \"%c\"."), options
->format
);
542 /* Specify default address for `x' command.
543 The `info lines' command uses this. */
546 set_next_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
548 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
550 next_gdbarch
= gdbarch
;
553 /* Make address available to the user as $_. */
554 set_internalvar (lookup_internalvar ("_"),
555 value_from_pointer (ptr_type
, addr
));
558 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
559 after LEADIN. Print nothing if no symbolic name is found nearby.
560 Optionally also print source file and line number, if available.
561 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
562 or to interpret it as a possible C++ name and convert it back to source
563 form. However note that DO_DEMANGLE can be overridden by the specific
564 settings of the demangle and asm_demangle variables. Returns
565 non-zero if anything was printed; zero otherwise. */
568 print_address_symbolic (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
569 struct ui_file
*stream
,
570 int do_demangle
, char *leadin
)
573 char *filename
= NULL
;
578 /* Throw away both name and filename. */
579 struct cleanup
*cleanup_chain
= make_cleanup (free_current_contents
, &name
);
580 make_cleanup (free_current_contents
, &filename
);
582 if (build_address_symbolic (gdbarch
, addr
, do_demangle
, &name
, &offset
,
583 &filename
, &line
, &unmapped
))
585 do_cleanups (cleanup_chain
);
589 fputs_filtered (leadin
, stream
);
591 fputs_filtered ("<*", stream
);
593 fputs_filtered ("<", stream
);
594 fputs_filtered (name
, stream
);
596 fprintf_filtered (stream
, "+%u", (unsigned int) offset
);
598 /* Append source filename and line number if desired. Give specific
599 line # of this addr, if we have it; else line # of the nearest symbol. */
600 if (print_symbol_filename
&& filename
!= NULL
)
603 fprintf_filtered (stream
, " at %s:%d", filename
, line
);
605 fprintf_filtered (stream
, " in %s", filename
);
608 fputs_filtered ("*>", stream
);
610 fputs_filtered (">", stream
);
612 do_cleanups (cleanup_chain
);
616 /* Given an address ADDR return all the elements needed to print the
617 address in a symbolic form. NAME can be mangled or not depending
618 on DO_DEMANGLE (and also on the asm_demangle global variable,
619 manipulated via ''set print asm-demangle''). Return 0 in case of
620 success, when all the info in the OUT paramters is valid. Return 1
623 build_address_symbolic (struct gdbarch
*gdbarch
,
624 CORE_ADDR addr
, /* IN */
625 int do_demangle
, /* IN */
626 char **name
, /* OUT */
627 int *offset
, /* OUT */
628 char **filename
, /* OUT */
630 int *unmapped
) /* OUT */
632 struct minimal_symbol
*msymbol
;
633 struct symbol
*symbol
;
634 CORE_ADDR name_location
= 0;
635 struct obj_section
*section
= NULL
;
636 const char *name_temp
= "";
638 /* Let's say it is mapped (not unmapped). */
641 /* Determine if the address is in an overlay, and whether it is
643 if (overlay_debugging
)
645 section
= find_pc_overlay (addr
);
646 if (pc_in_unmapped_range (addr
, section
))
649 addr
= overlay_mapped_address (addr
, section
);
653 /* First try to find the address in the symbol table, then
654 in the minsyms. Take the closest one. */
656 /* This is defective in the sense that it only finds text symbols. So
657 really this is kind of pointless--we should make sure that the
658 minimal symbols have everything we need (by changing that we could
659 save some memory, but for many debug format--ELF/DWARF or
660 anything/stabs--it would be inconvenient to eliminate those minimal
662 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
663 symbol
= find_pc_sect_function (addr
, section
);
667 /* If this is a function (i.e. a code address), strip out any
668 non-address bits. For instance, display a pointer to the
669 first instruction of a Thumb function as <function>; the
670 second instruction will be <function+2>, even though the
671 pointer is <function+3>. This matches the ISA behavior. */
672 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
674 name_location
= BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
));
675 if (do_demangle
|| asm_demangle
)
676 name_temp
= SYMBOL_PRINT_NAME (symbol
);
678 name_temp
= SYMBOL_LINKAGE_NAME (symbol
);
682 && MSYMBOL_HAS_SIZE (msymbol
)
683 && MSYMBOL_SIZE (msymbol
) == 0
684 && MSYMBOL_TYPE (msymbol
) != mst_text
685 && MSYMBOL_TYPE (msymbol
) != mst_text_gnu_ifunc
686 && MSYMBOL_TYPE (msymbol
) != mst_file_text
)
691 if (SYMBOL_VALUE_ADDRESS (msymbol
) > name_location
|| symbol
== NULL
)
693 /* The msymbol is closer to the address than the symbol;
694 use the msymbol instead. */
696 name_location
= SYMBOL_VALUE_ADDRESS (msymbol
);
697 if (do_demangle
|| asm_demangle
)
698 name_temp
= SYMBOL_PRINT_NAME (msymbol
);
700 name_temp
= SYMBOL_LINKAGE_NAME (msymbol
);
703 if (symbol
== NULL
&& msymbol
== NULL
)
706 /* If the nearest symbol is too far away, don't print anything symbolic. */
708 /* For when CORE_ADDR is larger than unsigned int, we do math in
709 CORE_ADDR. But when we detect unsigned wraparound in the
710 CORE_ADDR math, we ignore this test and print the offset,
711 because addr+max_symbolic_offset has wrapped through the end
712 of the address space back to the beginning, giving bogus comparison. */
713 if (addr
> name_location
+ max_symbolic_offset
714 && name_location
+ max_symbolic_offset
> name_location
)
717 *offset
= addr
- name_location
;
719 *name
= xstrdup (name_temp
);
721 if (print_symbol_filename
)
723 struct symtab_and_line sal
;
725 sal
= find_pc_sect_line (addr
, section
, 0);
729 *filename
= xstrdup (sal
.symtab
->filename
);
737 /* Print address ADDR symbolically on STREAM.
738 First print it as a number. Then perhaps print
739 <SYMBOL + OFFSET> after the number. */
742 print_address (struct gdbarch
*gdbarch
,
743 CORE_ADDR addr
, struct ui_file
*stream
)
745 fputs_filtered (paddress (gdbarch
, addr
), stream
);
746 print_address_symbolic (gdbarch
, addr
, stream
, asm_demangle
, " ");
749 /* Return a prefix for instruction address:
750 "=> " for current instruction, else " ". */
753 pc_prefix (CORE_ADDR addr
)
755 if (has_stack_frames ())
757 struct frame_info
*frame
;
760 frame
= get_selected_frame (NULL
);
761 if (get_frame_pc_if_available (frame
, &pc
) && pc
== addr
)
767 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
768 controls whether to print the symbolic name "raw" or demangled.
769 Return non-zero if anything was printed; zero otherwise. */
772 print_address_demangle (const struct value_print_options
*opts
,
773 struct gdbarch
*gdbarch
, CORE_ADDR addr
,
774 struct ui_file
*stream
, int do_demangle
)
776 if (opts
->addressprint
)
778 fputs_filtered (paddress (gdbarch
, addr
), stream
);
779 print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, " ");
783 return print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, "");
789 /* Examine data at address ADDR in format FMT.
790 Fetch it from memory and print on gdb_stdout. */
793 do_examine (struct format_data fmt
, struct gdbarch
*gdbarch
, CORE_ADDR addr
)
798 struct type
*val_type
= NULL
;
801 struct value_print_options opts
;
806 next_gdbarch
= gdbarch
;
809 /* Instruction format implies fetch single bytes
810 regardless of the specified size.
811 The case of strings is handled in decode_format, only explicit
812 size operator are not changed to 'b'. */
818 /* Pick the appropriate size for an address. */
819 if (gdbarch_ptr_bit (next_gdbarch
) == 64)
821 else if (gdbarch_ptr_bit (next_gdbarch
) == 32)
823 else if (gdbarch_ptr_bit (next_gdbarch
) == 16)
826 /* Bad value for gdbarch_ptr_bit. */
827 internal_error (__FILE__
, __LINE__
,
828 _("failed internal consistency check"));
832 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
833 else if (size
== 'h')
834 val_type
= builtin_type (next_gdbarch
)->builtin_int16
;
835 else if (size
== 'w')
836 val_type
= builtin_type (next_gdbarch
)->builtin_int32
;
837 else if (size
== 'g')
838 val_type
= builtin_type (next_gdbarch
)->builtin_int64
;
842 struct type
*char_type
= NULL
;
844 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
845 if type is not found. */
847 char_type
= builtin_type (next_gdbarch
)->builtin_char16
;
848 else if (size
== 'w')
849 char_type
= builtin_type (next_gdbarch
)->builtin_char32
;
851 val_type
= char_type
;
854 if (size
!= '\0' && size
!= 'b')
855 warning (_("Unable to display strings with "
856 "size '%c', using 'b' instead."), size
);
858 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
867 if (format
== 's' || format
== 'i')
870 get_formatted_print_options (&opts
, format
);
872 /* Print as many objects as specified in COUNT, at most maxelts per line,
873 with the address of the next one at the start of each line. */
879 fputs_filtered (pc_prefix (next_address
), gdb_stdout
);
880 print_address (next_gdbarch
, next_address
, gdb_stdout
);
881 printf_filtered (":");
886 printf_filtered ("\t");
887 /* Note that print_formatted sets next_address for the next
889 last_examine_address
= next_address
;
891 if (last_examine_value
)
892 value_free (last_examine_value
);
894 /* The value to be displayed is not fetched greedily.
895 Instead, to avoid the possibility of a fetched value not
896 being used, its retrieval is delayed until the print code
897 uses it. When examining an instruction stream, the
898 disassembler will perform its own memory fetch using just
899 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
900 the disassembler be modified so that LAST_EXAMINE_VALUE
901 is left with the byte sequence from the last complete
902 instruction fetched from memory? */
903 last_examine_value
= value_at_lazy (val_type
, next_address
);
905 if (last_examine_value
)
906 release_value (last_examine_value
);
908 print_formatted (last_examine_value
, size
, &opts
, gdb_stdout
);
910 /* Display any branch delay slots following the final insn. */
911 if (format
== 'i' && count
== 1)
912 count
+= branch_delay_insns
;
914 printf_filtered ("\n");
915 gdb_flush (gdb_stdout
);
920 validate_format (struct format_data fmt
, char *cmdname
)
923 error (_("Size letters are meaningless in \"%s\" command."), cmdname
);
925 error (_("Item count other than 1 is meaningless in \"%s\" command."),
927 if (fmt
.format
== 'i')
928 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
929 fmt
.format
, cmdname
);
932 /* Evaluate string EXP as an expression in the current language and
933 print the resulting value. EXP may contain a format specifier as the
934 first argument ("/x myvar" for example, to print myvar in hex). */
937 print_command_1 (char *exp
, int voidprint
)
939 struct expression
*expr
;
940 struct cleanup
*old_chain
= 0;
943 struct format_data fmt
;
946 if (exp
&& *exp
== '/')
949 fmt
= decode_format (&exp
, last_format
, 0);
950 validate_format (fmt
, "print");
951 last_format
= format
= fmt
.format
;
963 expr
= parse_expression (exp
);
964 old_chain
= make_cleanup (free_current_contents
, &expr
);
966 val
= evaluate_expression (expr
);
969 val
= access_value_history (0);
971 if (voidprint
|| (val
&& value_type (val
) &&
972 TYPE_CODE (value_type (val
)) != TYPE_CODE_VOID
))
974 struct value_print_options opts
;
975 int histindex
= record_latest_value (val
);
978 annotate_value_history_begin (histindex
, value_type (val
));
980 annotate_value_begin (value_type (val
));
983 printf_filtered ("$%d = ", histindex
);
986 annotate_value_history_value ();
988 get_formatted_print_options (&opts
, format
);
991 print_formatted (val
, fmt
.size
, &opts
, gdb_stdout
);
992 printf_filtered ("\n");
995 annotate_value_history_end ();
997 annotate_value_end ();
1001 do_cleanups (old_chain
);
1005 print_command (char *exp
, int from_tty
)
1007 print_command_1 (exp
, 1);
1010 /* Same as print, except it doesn't print void results. */
1012 call_command (char *exp
, int from_tty
)
1014 print_command_1 (exp
, 0);
1018 output_command (char *exp
, int from_tty
)
1020 struct expression
*expr
;
1021 struct cleanup
*old_chain
;
1024 struct format_data fmt
;
1025 struct value_print_options opts
;
1030 if (exp
&& *exp
== '/')
1033 fmt
= decode_format (&exp
, 0, 0);
1034 validate_format (fmt
, "output");
1035 format
= fmt
.format
;
1038 expr
= parse_expression (exp
);
1039 old_chain
= make_cleanup (free_current_contents
, &expr
);
1041 val
= evaluate_expression (expr
);
1043 annotate_value_begin (value_type (val
));
1045 get_formatted_print_options (&opts
, format
);
1047 print_formatted (val
, fmt
.size
, &opts
, gdb_stdout
);
1049 annotate_value_end ();
1052 gdb_flush (gdb_stdout
);
1054 do_cleanups (old_chain
);
1058 set_command (char *exp
, int from_tty
)
1060 struct expression
*expr
= parse_expression (exp
);
1061 struct cleanup
*old_chain
=
1062 make_cleanup (free_current_contents
, &expr
);
1064 if (expr
->nelts
>= 1)
1065 switch (expr
->elts
[0].opcode
)
1067 case UNOP_PREINCREMENT
:
1068 case UNOP_POSTINCREMENT
:
1069 case UNOP_PREDECREMENT
:
1070 case UNOP_POSTDECREMENT
:
1072 case BINOP_ASSIGN_MODIFY
:
1077 (_("Expression is not an assignment (and might have no effect)"));
1080 evaluate_expression (expr
);
1081 do_cleanups (old_chain
);
1085 sym_info (char *arg
, int from_tty
)
1087 struct minimal_symbol
*msymbol
;
1088 struct objfile
*objfile
;
1089 struct obj_section
*osect
;
1090 CORE_ADDR addr
, sect_addr
;
1092 unsigned int offset
;
1095 error_no_arg (_("address"));
1097 addr
= parse_and_eval_address (arg
);
1098 ALL_OBJSECTIONS (objfile
, osect
)
1100 /* Only process each object file once, even if there's a separate
1102 if (objfile
->separate_debug_objfile_backlink
)
1105 sect_addr
= overlay_mapped_address (addr
, osect
);
1107 if (obj_section_addr (osect
) <= sect_addr
1108 && sect_addr
< obj_section_endaddr (osect
)
1109 && (msymbol
= lookup_minimal_symbol_by_pc_section (sect_addr
, osect
)))
1111 const char *obj_name
, *mapped
, *sec_name
, *msym_name
;
1113 struct cleanup
*old_chain
;
1116 offset
= sect_addr
- SYMBOL_VALUE_ADDRESS (msymbol
);
1117 mapped
= section_is_mapped (osect
) ? _("mapped") : _("unmapped");
1118 sec_name
= osect
->the_bfd_section
->name
;
1119 msym_name
= SYMBOL_PRINT_NAME (msymbol
);
1121 /* Don't print the offset if it is zero.
1122 We assume there's no need to handle i18n of "sym + offset". */
1124 loc_string
= xstrprintf ("%s + %u", msym_name
, offset
);
1126 loc_string
= xstrprintf ("%s", msym_name
);
1128 /* Use a cleanup to free loc_string in case the user quits
1129 a pagination request inside printf_filtered. */
1130 old_chain
= make_cleanup (xfree
, loc_string
);
1132 gdb_assert (osect
->objfile
&& osect
->objfile
->name
);
1133 obj_name
= osect
->objfile
->name
;
1135 if (MULTI_OBJFILE_P ())
1136 if (pc_in_unmapped_range (addr
, osect
))
1137 if (section_is_overlay (osect
))
1138 printf_filtered (_("%s in load address range of "
1139 "%s overlay section %s of %s\n"),
1140 loc_string
, mapped
, sec_name
, obj_name
);
1142 printf_filtered (_("%s in load address range of "
1143 "section %s of %s\n"),
1144 loc_string
, sec_name
, obj_name
);
1146 if (section_is_overlay (osect
))
1147 printf_filtered (_("%s in %s overlay section %s of %s\n"),
1148 loc_string
, mapped
, sec_name
, obj_name
);
1150 printf_filtered (_("%s in section %s of %s\n"),
1151 loc_string
, sec_name
, obj_name
);
1153 if (pc_in_unmapped_range (addr
, osect
))
1154 if (section_is_overlay (osect
))
1155 printf_filtered (_("%s in load address range of %s overlay "
1157 loc_string
, mapped
, sec_name
);
1159 printf_filtered (_("%s in load address range of section %s\n"),
1160 loc_string
, sec_name
);
1162 if (section_is_overlay (osect
))
1163 printf_filtered (_("%s in %s overlay section %s\n"),
1164 loc_string
, mapped
, sec_name
);
1166 printf_filtered (_("%s in section %s\n"),
1167 loc_string
, sec_name
);
1169 do_cleanups (old_chain
);
1173 printf_filtered (_("No symbol matches %s.\n"), arg
);
1177 address_info (char *exp
, int from_tty
)
1179 struct gdbarch
*gdbarch
;
1182 struct minimal_symbol
*msymbol
;
1184 struct obj_section
*section
;
1185 CORE_ADDR load_addr
, context_pc
= 0;
1186 struct field_of_this_result is_a_field_of_this
;
1189 error (_("Argument required."));
1191 sym
= lookup_symbol (exp
, get_selected_block (&context_pc
), VAR_DOMAIN
,
1192 &is_a_field_of_this
);
1195 if (is_a_field_of_this
.type
!= NULL
)
1197 printf_filtered ("Symbol \"");
1198 fprintf_symbol_filtered (gdb_stdout
, exp
,
1199 current_language
->la_language
, DMGL_ANSI
);
1200 printf_filtered ("\" is a field of the local class variable ");
1201 if (current_language
->la_language
== language_objc
)
1202 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1204 printf_filtered ("`this'\n");
1208 msymbol
= lookup_minimal_symbol (exp
, NULL
, NULL
);
1210 if (msymbol
!= NULL
)
1212 gdbarch
= get_objfile_arch (msymbol_objfile (msymbol
));
1213 load_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1215 printf_filtered ("Symbol \"");
1216 fprintf_symbol_filtered (gdb_stdout
, exp
,
1217 current_language
->la_language
, DMGL_ANSI
);
1218 printf_filtered ("\" is at ");
1219 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1220 printf_filtered (" in a file compiled without debugging");
1221 section
= SYMBOL_OBJ_SECTION (msymbol
);
1222 if (section_is_overlay (section
))
1224 load_addr
= overlay_unmapped_address (load_addr
, section
);
1225 printf_filtered (",\n -- loaded at ");
1226 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1227 printf_filtered (" in overlay section %s",
1228 section
->the_bfd_section
->name
);
1230 printf_filtered (".\n");
1233 error (_("No symbol \"%s\" in current context."), exp
);
1237 printf_filtered ("Symbol \"");
1238 fprintf_symbol_filtered (gdb_stdout
, SYMBOL_PRINT_NAME (sym
),
1239 current_language
->la_language
, DMGL_ANSI
);
1240 printf_filtered ("\" is ");
1241 val
= SYMBOL_VALUE (sym
);
1242 section
= SYMBOL_OBJ_SECTION (sym
);
1243 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
1245 switch (SYMBOL_CLASS (sym
))
1248 case LOC_CONST_BYTES
:
1249 printf_filtered ("constant");
1253 printf_filtered ("a label at address ");
1254 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1255 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1256 if (section_is_overlay (section
))
1258 load_addr
= overlay_unmapped_address (load_addr
, section
);
1259 printf_filtered (",\n -- loaded at ");
1260 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1261 printf_filtered (" in overlay section %s",
1262 section
->the_bfd_section
->name
);
1267 /* FIXME: cagney/2004-01-26: It should be possible to
1268 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
1269 Unfortunately DWARF 2 stores the frame-base (instead of the
1270 function) location in a function's symbol. Oops! For the
1271 moment enable this when/where applicable. */
1272 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, context_pc
,
1277 /* GDBARCH is the architecture associated with the objfile the symbol
1278 is defined in; the target architecture may be different, and may
1279 provide additional registers. However, we do not know the target
1280 architecture at this point. We assume the objfile architecture
1281 will contain all the standard registers that occur in debug info
1283 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1285 if (SYMBOL_IS_ARGUMENT (sym
))
1286 printf_filtered (_("an argument in register %s"),
1287 gdbarch_register_name (gdbarch
, regno
));
1289 printf_filtered (_("a variable in register %s"),
1290 gdbarch_register_name (gdbarch
, regno
));
1294 printf_filtered (_("static storage at address "));
1295 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1296 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1297 if (section_is_overlay (section
))
1299 load_addr
= overlay_unmapped_address (load_addr
, section
);
1300 printf_filtered (_(",\n -- loaded at "));
1301 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1302 printf_filtered (_(" in overlay section %s"),
1303 section
->the_bfd_section
->name
);
1307 case LOC_REGPARM_ADDR
:
1308 /* Note comment at LOC_REGISTER. */
1309 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1310 printf_filtered (_("address of an argument in register %s"),
1311 gdbarch_register_name (gdbarch
, regno
));
1315 printf_filtered (_("an argument at offset %ld"), val
);
1319 printf_filtered (_("a local variable at frame offset %ld"), val
);
1323 printf_filtered (_("a reference argument at offset %ld"), val
);
1327 printf_filtered (_("a typedef"));
1331 printf_filtered (_("a function at address "));
1332 load_addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1333 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1334 if (section_is_overlay (section
))
1336 load_addr
= overlay_unmapped_address (load_addr
, section
);
1337 printf_filtered (_(",\n -- loaded at "));
1338 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1339 printf_filtered (_(" in overlay section %s"),
1340 section
->the_bfd_section
->name
);
1344 case LOC_UNRESOLVED
:
1346 struct minimal_symbol
*msym
;
1348 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
), NULL
, NULL
);
1350 printf_filtered ("unresolved");
1353 section
= SYMBOL_OBJ_SECTION (msym
);
1354 load_addr
= SYMBOL_VALUE_ADDRESS (msym
);
1357 && (section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
1358 printf_filtered (_("a thread-local variable at offset %s "
1359 "in the thread-local storage for `%s'"),
1360 paddress (gdbarch
, load_addr
),
1361 section
->objfile
->name
);
1364 printf_filtered (_("static storage at address "));
1365 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1366 if (section_is_overlay (section
))
1368 load_addr
= overlay_unmapped_address (load_addr
, section
);
1369 printf_filtered (_(",\n -- loaded at "));
1370 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1371 printf_filtered (_(" in overlay section %s"),
1372 section
->the_bfd_section
->name
);
1379 case LOC_OPTIMIZED_OUT
:
1380 printf_filtered (_("optimized out"));
1384 printf_filtered (_("of unknown (botched) type"));
1387 printf_filtered (".\n");
1392 x_command (char *exp
, int from_tty
)
1394 struct expression
*expr
;
1395 struct format_data fmt
;
1396 struct cleanup
*old_chain
;
1399 fmt
.format
= last_format
? last_format
: 'x';
1400 fmt
.size
= last_size
;
1404 if (exp
&& *exp
== '/')
1407 fmt
= decode_format (&exp
, last_format
, last_size
);
1410 /* If we have an expression, evaluate it and use it as the address. */
1412 if (exp
!= 0 && *exp
!= 0)
1414 expr
= parse_expression (exp
);
1415 /* Cause expression not to be there any more if this command is
1416 repeated with Newline. But don't clobber a user-defined
1417 command's definition. */
1420 old_chain
= make_cleanup (free_current_contents
, &expr
);
1421 val
= evaluate_expression (expr
);
1422 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_REF
)
1423 val
= coerce_ref (val
);
1424 /* In rvalue contexts, such as this, functions are coerced into
1425 pointers to functions. This makes "x/i main" work. */
1426 if (/* last_format == 'i' && */
1427 TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
1428 && VALUE_LVAL (val
) == lval_memory
)
1429 next_address
= value_address (val
);
1431 next_address
= value_as_address (val
);
1433 next_gdbarch
= expr
->gdbarch
;
1434 do_cleanups (old_chain
);
1438 error_no_arg (_("starting display address"));
1440 do_examine (fmt
, next_gdbarch
, next_address
);
1442 /* If the examine succeeds, we remember its size and format for next
1443 time. Set last_size to 'b' for strings. */
1444 if (fmt
.format
== 's')
1447 last_size
= fmt
.size
;
1448 last_format
= fmt
.format
;
1450 /* Set a couple of internal variables if appropriate. */
1451 if (last_examine_value
)
1453 /* Make last address examined available to the user as $_. Use
1454 the correct pointer type. */
1455 struct type
*pointer_type
1456 = lookup_pointer_type (value_type (last_examine_value
));
1457 set_internalvar (lookup_internalvar ("_"),
1458 value_from_pointer (pointer_type
,
1459 last_examine_address
));
1461 /* Make contents of last address examined available to the user
1462 as $__. If the last value has not been fetched from memory
1463 then don't fetch it now; instead mark it by voiding the $__
1465 if (value_lazy (last_examine_value
))
1466 clear_internalvar (lookup_internalvar ("__"));
1468 set_internalvar (lookup_internalvar ("__"), last_examine_value
);
1473 /* Add an expression to the auto-display chain.
1474 Specify the expression. */
1477 display_command (char *exp
, int from_tty
)
1479 struct format_data fmt
;
1480 struct expression
*expr
;
1481 struct display
*new;
1485 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1487 if (tui_active
&& exp
!= NULL
&& *exp
== '$')
1488 display_it
= (tui_set_layout_for_display_command (exp
) == TUI_FAILURE
);
1502 fmt
= decode_format (&exp
, 0, 0);
1503 if (fmt
.size
&& fmt
.format
== 0)
1505 if (fmt
.format
== 'i' || fmt
.format
== 's')
1516 innermost_block
= NULL
;
1517 expr
= parse_expression (exp
);
1519 new = (struct display
*) xmalloc (sizeof (struct display
));
1521 new->exp_string
= xstrdup (exp
);
1523 new->block
= innermost_block
;
1524 new->pspace
= current_program_space
;
1525 new->next
= display_chain
;
1526 new->number
= ++display_number
;
1529 display_chain
= new;
1531 if (from_tty
&& target_has_execution
)
1532 do_one_display (new);
1539 free_display (struct display
*d
)
1541 xfree (d
->exp_string
);
1546 /* Clear out the display_chain. Done when new symtabs are loaded,
1547 since this invalidates the types stored in many expressions. */
1550 clear_displays (void)
1554 while ((d
= display_chain
) != NULL
)
1556 display_chain
= d
->next
;
1561 /* Delete the auto-display DISPLAY. */
1564 delete_display (struct display
*display
)
1568 gdb_assert (display
!= NULL
);
1570 if (display_chain
== display
)
1571 display_chain
= display
->next
;
1574 if (d
->next
== display
)
1576 d
->next
= display
->next
;
1580 free_display (display
);
1583 /* Call FUNCTION on each of the displays whose numbers are given in
1584 ARGS. DATA is passed unmodified to FUNCTION. */
1587 map_display_numbers (char *args
,
1588 void (*function
) (struct display
*,
1592 struct get_number_or_range_state state
;
1596 error_no_arg (_("one or more display numbers"));
1598 init_number_or_range (&state
, args
);
1600 while (!state
.finished
)
1602 char *p
= state
.string
;
1604 num
= get_number_or_range (&state
);
1606 warning (_("bad display number at or near '%s'"), p
);
1609 struct display
*d
, *tmp
;
1611 ALL_DISPLAYS_SAFE (d
, tmp
)
1612 if (d
->number
== num
)
1615 printf_unfiltered (_("No display number %d.\n"), num
);
1622 /* Callback for map_display_numbers, that deletes a display. */
1625 do_delete_display (struct display
*d
, void *data
)
1630 /* "undisplay" command. */
1633 undisplay_command (char *args
, int from_tty
)
1637 if (query (_("Delete all auto-display expressions? ")))
1643 map_display_numbers (args
, do_delete_display
, NULL
);
1647 /* Display a single auto-display.
1648 Do nothing if the display cannot be printed in the current context,
1649 or if the display is disabled. */
1652 do_one_display (struct display
*d
)
1654 struct cleanup
*old_chain
;
1655 int within_current_scope
;
1657 if (d
->enabled_p
== 0)
1660 /* The expression carries the architecture that was used at parse time.
1661 This is a problem if the expression depends on architecture features
1662 (e.g. register numbers), and the current architecture is now different.
1663 For example, a display statement like "display/i $pc" is expected to
1664 display the PC register of the current architecture, not the arch at
1665 the time the display command was given. Therefore, we re-parse the
1666 expression if the current architecture has changed. */
1667 if (d
->exp
!= NULL
&& d
->exp
->gdbarch
!= get_current_arch ())
1676 volatile struct gdb_exception ex
;
1678 TRY_CATCH (ex
, RETURN_MASK_ALL
)
1680 innermost_block
= NULL
;
1681 d
->exp
= parse_expression (d
->exp_string
);
1682 d
->block
= innermost_block
;
1686 /* Can't re-parse the expression. Disable this display item. */
1688 warning (_("Unable to display \"%s\": %s"),
1689 d
->exp_string
, ex
.message
);
1696 if (d
->pspace
== current_program_space
)
1697 within_current_scope
= contained_in (get_selected_block (0), d
->block
);
1699 within_current_scope
= 0;
1702 within_current_scope
= 1;
1703 if (!within_current_scope
)
1706 old_chain
= make_cleanup_restore_integer (¤t_display_number
);
1707 current_display_number
= d
->number
;
1709 annotate_display_begin ();
1710 printf_filtered ("%d", d
->number
);
1711 annotate_display_number_end ();
1712 printf_filtered (": ");
1715 volatile struct gdb_exception ex
;
1717 annotate_display_format ();
1719 printf_filtered ("x/");
1720 if (d
->format
.count
!= 1)
1721 printf_filtered ("%d", d
->format
.count
);
1722 printf_filtered ("%c", d
->format
.format
);
1723 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1724 printf_filtered ("%c", d
->format
.size
);
1725 printf_filtered (" ");
1727 annotate_display_expression ();
1729 puts_filtered (d
->exp_string
);
1730 annotate_display_expression_end ();
1732 if (d
->format
.count
!= 1 || d
->format
.format
== 'i')
1733 printf_filtered ("\n");
1735 printf_filtered (" ");
1737 annotate_display_value ();
1739 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
1744 val
= evaluate_expression (d
->exp
);
1745 addr
= value_as_address (val
);
1746 if (d
->format
.format
== 'i')
1747 addr
= gdbarch_addr_bits_remove (d
->exp
->gdbarch
, addr
);
1748 do_examine (d
->format
, d
->exp
->gdbarch
, addr
);
1751 fprintf_filtered (gdb_stdout
, _("<error: %s>\n"), ex
.message
);
1755 struct value_print_options opts
;
1756 volatile struct gdb_exception ex
;
1758 annotate_display_format ();
1760 if (d
->format
.format
)
1761 printf_filtered ("/%c ", d
->format
.format
);
1763 annotate_display_expression ();
1765 puts_filtered (d
->exp_string
);
1766 annotate_display_expression_end ();
1768 printf_filtered (" = ");
1770 annotate_display_expression ();
1772 get_formatted_print_options (&opts
, d
->format
.format
);
1773 opts
.raw
= d
->format
.raw
;
1775 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
1779 val
= evaluate_expression (d
->exp
);
1780 print_formatted (val
, d
->format
.size
, &opts
, gdb_stdout
);
1783 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
1784 printf_filtered ("\n");
1787 annotate_display_end ();
1789 gdb_flush (gdb_stdout
);
1790 do_cleanups (old_chain
);
1793 /* Display all of the values on the auto-display chain which can be
1794 evaluated in the current scope. */
1801 for (d
= display_chain
; d
; d
= d
->next
)
1805 /* Delete the auto-display which we were in the process of displaying.
1806 This is done when there is an error or a signal. */
1809 disable_display (int num
)
1813 for (d
= display_chain
; d
; d
= d
->next
)
1814 if (d
->number
== num
)
1819 printf_unfiltered (_("No display number %d.\n"), num
);
1823 disable_current_display (void)
1825 if (current_display_number
>= 0)
1827 disable_display (current_display_number
);
1828 fprintf_unfiltered (gdb_stderr
,
1829 _("Disabling display %d to "
1830 "avoid infinite recursion.\n"),
1831 current_display_number
);
1833 current_display_number
= -1;
1837 display_info (char *ignore
, int from_tty
)
1842 printf_unfiltered (_("There are no auto-display expressions now.\n"));
1844 printf_filtered (_("Auto-display expressions now in effect:\n\
1845 Num Enb Expression\n"));
1847 for (d
= display_chain
; d
; d
= d
->next
)
1849 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
1851 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
1853 else if (d
->format
.format
)
1854 printf_filtered ("/%c ", d
->format
.format
);
1855 puts_filtered (d
->exp_string
);
1856 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
))
1857 printf_filtered (_(" (cannot be evaluated in the current context)"));
1858 printf_filtered ("\n");
1859 gdb_flush (gdb_stdout
);
1863 /* Callback fo map_display_numbers, that enables or disables the
1864 passed in display D. */
1867 do_enable_disable_display (struct display
*d
, void *data
)
1869 d
->enabled_p
= *(int *) data
;
1872 /* Implamentation of both the "disable display" and "enable display"
1873 commands. ENABLE decides what to do. */
1876 enable_disable_display_command (char *args
, int from_tty
, int enable
)
1883 d
->enabled_p
= enable
;
1887 map_display_numbers (args
, do_enable_disable_display
, &enable
);
1890 /* The "enable display" command. */
1893 enable_display_command (char *args
, int from_tty
)
1895 enable_disable_display_command (args
, from_tty
, 1);
1898 /* The "disable display" command. */
1901 disable_display_command (char *args
, int from_tty
)
1903 enable_disable_display_command (args
, from_tty
, 0);
1906 /* display_chain items point to blocks and expressions. Some expressions in
1907 turn may point to symbols.
1908 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
1909 obstack_free'd when a shared library is unloaded.
1910 Clear pointers that are about to become dangling.
1911 Both .exp and .block fields will be restored next time we need to display
1912 an item by re-parsing .exp_string field in the new execution context. */
1915 clear_dangling_display_expressions (struct so_list
*solib
)
1917 struct objfile
*objfile
= solib
->objfile
;
1920 /* With no symbol file we cannot have a block or expression from it. */
1921 if (objfile
== NULL
)
1923 if (objfile
->separate_debug_objfile_backlink
)
1924 objfile
= objfile
->separate_debug_objfile_backlink
;
1925 gdb_assert (objfile
->pspace
== solib
->pspace
);
1927 for (d
= display_chain
; d
!= NULL
; d
= d
->next
)
1929 if (d
->pspace
!= solib
->pspace
)
1932 if (lookup_objfile_from_block (d
->block
) == objfile
1933 || (d
->exp
&& exp_uses_objfile (d
->exp
, objfile
)))
1943 /* Print the value in stack frame FRAME of a variable specified by a
1944 struct symbol. NAME is the name to print; if NULL then VAR's print
1945 name will be used. STREAM is the ui_file on which to print the
1946 value. INDENT specifies the number of indent levels to print
1947 before printing the variable name.
1949 This function invalidates FRAME. */
1952 print_variable_and_value (const char *name
, struct symbol
*var
,
1953 struct frame_info
*frame
,
1954 struct ui_file
*stream
, int indent
)
1956 volatile struct gdb_exception except
;
1959 name
= SYMBOL_PRINT_NAME (var
);
1961 fprintf_filtered (stream
, "%s%s = ", n_spaces (2 * indent
), name
);
1962 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1965 struct value_print_options opts
;
1967 val
= read_var_value (var
, frame
);
1968 get_user_print_options (&opts
);
1970 common_val_print (val
, stream
, indent
, &opts
, current_language
);
1972 /* common_val_print invalidates FRAME when a pretty printer calls inferior
1976 if (except
.reason
< 0)
1977 fprintf_filtered(stream
, "<error reading variable %s (%s)>", name
,
1979 fprintf_filtered (stream
, "\n");
1982 /* printf "printf format string" ARG to STREAM. */
1985 ui_printf (char *arg
, struct ui_file
*stream
)
1987 struct format_piece
*fpieces
;
1989 struct value
**val_args
;
1990 int allocated_args
= 20;
1991 struct cleanup
*old_cleanups
;
1993 val_args
= xmalloc (allocated_args
* sizeof (struct value
*));
1994 old_cleanups
= make_cleanup (free_current_contents
, &val_args
);
1997 error_no_arg (_("format-control string and values to print"));
1999 s
= skip_spaces (s
);
2001 /* A format string should follow, enveloped in double quotes. */
2003 error (_("Bad format string, missing '\"'."));
2005 fpieces
= parse_format_string (&s
);
2007 make_cleanup (free_format_pieces_cleanup
, &fpieces
);
2010 error (_("Bad format string, non-terminated '\"'."));
2012 s
= skip_spaces (s
);
2014 if (*s
!= ',' && *s
!= 0)
2015 error (_("Invalid argument syntax"));
2019 s
= skip_spaces (s
);
2025 char *current_substring
;
2028 for (fr
= 0; fpieces
[fr
].string
!= NULL
; fr
++)
2029 if (fpieces
[fr
].argclass
!= literal_piece
)
2032 /* Now, parse all arguments and evaluate them.
2033 Store the VALUEs in VAL_ARGS. */
2039 if (nargs
== allocated_args
)
2040 val_args
= (struct value
**) xrealloc ((char *) val_args
,
2041 (allocated_args
*= 2)
2042 * sizeof (struct value
*));
2044 val_args
[nargs
] = parse_to_comma_and_eval (&s1
);
2052 if (nargs
!= nargs_wanted
)
2053 error (_("Wrong number of arguments for specified format-string"));
2055 /* Now actually print them. */
2057 for (fr
= 0; fpieces
[fr
].string
!= NULL
; fr
++)
2059 current_substring
= fpieces
[fr
].string
;
2060 switch (fpieces
[fr
].argclass
)
2068 tem
= value_as_address (val_args
[i
]);
2070 /* This is a %s argument. Find the length of the string. */
2076 read_memory (tem
+ j
, &c
, 1);
2081 /* Copy the string contents into a string inside GDB. */
2082 str
= (gdb_byte
*) alloca (j
+ 1);
2084 read_memory (tem
, str
, j
);
2087 fprintf_filtered (stream
, current_substring
, (char *) str
);
2090 case wide_string_arg
:
2095 struct gdbarch
*gdbarch
2096 = get_type_arch (value_type (val_args
[i
]));
2097 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2098 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2099 "wchar_t", NULL
, 0);
2100 int wcwidth
= TYPE_LENGTH (wctype
);
2101 gdb_byte
*buf
= alloca (wcwidth
);
2102 struct obstack output
;
2103 struct cleanup
*inner_cleanup
;
2105 tem
= value_as_address (val_args
[i
]);
2107 /* This is a %s argument. Find the length of the string. */
2108 for (j
= 0;; j
+= wcwidth
)
2111 read_memory (tem
+ j
, buf
, wcwidth
);
2112 if (extract_unsigned_integer (buf
, wcwidth
, byte_order
) == 0)
2116 /* Copy the string contents into a string inside GDB. */
2117 str
= (gdb_byte
*) alloca (j
+ wcwidth
);
2119 read_memory (tem
, str
, j
);
2120 memset (&str
[j
], 0, wcwidth
);
2122 obstack_init (&output
);
2123 inner_cleanup
= make_cleanup_obstack_free (&output
);
2125 convert_between_encodings (target_wide_charset (gdbarch
),
2128 &output
, translit_char
);
2129 obstack_grow_str0 (&output
, "");
2131 fprintf_filtered (stream
, current_substring
,
2132 obstack_base (&output
));
2133 do_cleanups (inner_cleanup
);
2138 struct gdbarch
*gdbarch
2139 = get_type_arch (value_type (val_args
[i
]));
2140 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2141 "wchar_t", NULL
, 0);
2142 struct type
*valtype
;
2143 struct obstack output
;
2144 struct cleanup
*inner_cleanup
;
2145 const gdb_byte
*bytes
;
2147 valtype
= value_type (val_args
[i
]);
2148 if (TYPE_LENGTH (valtype
) != TYPE_LENGTH (wctype
)
2149 || TYPE_CODE (valtype
) != TYPE_CODE_INT
)
2150 error (_("expected wchar_t argument for %%lc"));
2152 bytes
= value_contents (val_args
[i
]);
2154 obstack_init (&output
);
2155 inner_cleanup
= make_cleanup_obstack_free (&output
);
2157 convert_between_encodings (target_wide_charset (gdbarch
),
2159 bytes
, TYPE_LENGTH (valtype
),
2160 TYPE_LENGTH (valtype
),
2161 &output
, translit_char
);
2162 obstack_grow_str0 (&output
, "");
2164 fprintf_filtered (stream
, current_substring
,
2165 obstack_base (&output
));
2166 do_cleanups (inner_cleanup
);
2171 struct type
*type
= value_type (val_args
[i
]);
2175 /* If format string wants a float, unchecked-convert the value
2176 to floating point of the same size. */
2177 type
= float_type_from_length (type
);
2178 val
= unpack_double (type
, value_contents (val_args
[i
]), &inv
);
2180 error (_("Invalid floating value found in program."));
2182 fprintf_filtered (stream
, current_substring
, (double) val
);
2185 case long_double_arg
:
2186 #ifdef HAVE_LONG_DOUBLE
2188 struct type
*type
= value_type (val_args
[i
]);
2192 /* If format string wants a float, unchecked-convert the value
2193 to floating point of the same size. */
2194 type
= float_type_from_length (type
);
2195 val
= unpack_double (type
, value_contents (val_args
[i
]), &inv
);
2197 error (_("Invalid floating value found in program."));
2199 fprintf_filtered (stream
, current_substring
,
2204 error (_("long double not supported in printf"));
2207 #ifdef PRINTF_HAS_LONG_LONG
2209 long long val
= value_as_long (val_args
[i
]);
2211 fprintf_filtered (stream
, current_substring
, val
);
2215 error (_("long long not supported in printf"));
2219 int val
= value_as_long (val_args
[i
]);
2221 fprintf_filtered (stream
, current_substring
, val
);
2226 long val
= value_as_long (val_args
[i
]);
2228 fprintf_filtered (stream
, current_substring
, val
);
2232 /* Handles decimal floating values. */
2235 const gdb_byte
*param_ptr
= value_contents (val_args
[i
]);
2237 #if defined (PRINTF_HAS_DECFLOAT)
2238 /* If we have native support for Decimal floating
2239 printing, handle it here. */
2240 fprintf_filtered (stream
, current_substring
, param_ptr
);
2243 /* As a workaround until vasprintf has native support for DFP
2244 we convert the DFP values to string and print them using
2245 the %s format specifier. */
2248 int nnull_chars
= 0;
2250 /* Parameter data. */
2251 struct type
*param_type
= value_type (val_args
[i
]);
2252 struct gdbarch
*gdbarch
= get_type_arch (param_type
);
2253 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2255 /* DFP output data. */
2256 struct value
*dfp_value
= NULL
;
2260 struct type
*dfp_type
= NULL
;
2261 char decstr
[MAX_DECIMAL_STRING
];
2263 /* Points to the end of the string so that we can go back
2264 and check for DFP length modifiers. */
2265 eos
= current_substring
+ strlen (current_substring
);
2267 /* Look for the float/double format specifier. */
2268 while (*eos
!= 'f' && *eos
!= 'e' && *eos
!= 'E'
2269 && *eos
!= 'g' && *eos
!= 'G')
2274 /* Search for the '%' char and extract the size and type of
2275 the output decimal value based on its modifiers
2276 (%Hf, %Df, %DDf). */
2277 while (*--sos
!= '%')
2282 dfp_type
= builtin_type (gdbarch
)->builtin_decfloat
;
2284 else if (*sos
== 'D' && *(sos
- 1) == 'D')
2287 dfp_type
= builtin_type (gdbarch
)->builtin_declong
;
2293 dfp_type
= builtin_type (gdbarch
)->builtin_decdouble
;
2297 /* Replace %Hf, %Df and %DDf with %s's. */
2300 /* Go through the whole format string and pull the correct
2301 number of chars back to compensate for the change in the
2302 format specifier. */
2303 while (nnull_chars
< nargs
- i
)
2311 /* Conversion between different DFP types. */
2312 if (TYPE_CODE (param_type
) == TYPE_CODE_DECFLOAT
)
2313 decimal_convert (param_ptr
, TYPE_LENGTH (param_type
),
2314 byte_order
, dec
, dfp_len
, byte_order
);
2316 /* If this is a non-trivial conversion, just output 0.
2317 A correct converted value can be displayed by explicitly
2318 casting to a DFP type. */
2319 decimal_from_string (dec
, dfp_len
, byte_order
, "0");
2321 dfp_value
= value_from_decfloat (dfp_type
, dec
);
2323 dfp_ptr
= (gdb_byte
*) value_contents (dfp_value
);
2325 decimal_to_string (dfp_ptr
, dfp_len
, byte_order
, decstr
);
2327 /* Print the DFP value. */
2328 fprintf_filtered (stream
, current_substring
, decstr
);
2336 /* We avoid the host's %p because pointers are too
2337 likely to be the wrong size. The only interesting
2338 modifier for %p is a width; extract that, and then
2339 handle %p as glibc would: %#x or a literal "(nil)". */
2341 char *p
, *fmt
, *fmt_p
;
2342 #ifdef PRINTF_HAS_LONG_LONG
2343 long long val
= value_as_long (val_args
[i
]);
2345 long val
= value_as_long (val_args
[i
]);
2348 fmt
= alloca (strlen (current_substring
) + 5);
2350 /* Copy up to the leading %. */
2351 p
= current_substring
;
2355 int is_percent
= (*p
== '%');
2370 /* Copy any width. */
2371 while (*p
>= '0' && *p
< '9')
2374 gdb_assert (*p
== 'p' && *(p
+ 1) == '\0');
2377 #ifdef PRINTF_HAS_LONG_LONG
2383 fprintf_filtered (stream
, fmt
, val
);
2389 fprintf_filtered (stream
, fmt
, "(nil)");
2395 /* Print a portion of the format string that has no
2396 directives. Note that this will not include any
2397 ordinary %-specs, but it might include "%%". That is
2398 why we use printf_filtered and not puts_filtered here.
2399 Also, we pass a dummy argument because some platforms
2400 have modified GCC to include -Wformat-security by
2401 default, which will warn here if there is no
2403 fprintf_filtered (stream
, current_substring
, 0);
2406 internal_error (__FILE__
, __LINE__
,
2407 _("failed internal consistency check"));
2409 /* Maybe advance to the next argument. */
2410 if (fpieces
[fr
].argclass
!= literal_piece
)
2414 do_cleanups (old_cleanups
);
2417 /* Implement the "printf" command. */
2420 printf_command (char *arg
, int from_tty
)
2422 ui_printf (arg
, gdb_stdout
);
2425 /* Implement the "eval" command. */
2428 eval_command (char *arg
, int from_tty
)
2430 struct ui_file
*ui_out
= mem_fileopen ();
2431 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (ui_out
);
2434 ui_printf (arg
, ui_out
);
2436 expanded
= ui_file_xstrdup (ui_out
, NULL
);
2437 make_cleanup (xfree
, expanded
);
2439 execute_command (expanded
, from_tty
);
2441 do_cleanups (cleanups
);
2445 _initialize_printcmd (void)
2447 struct cmd_list_element
*c
;
2449 current_display_number
= -1;
2451 observer_attach_solib_unloaded (clear_dangling_display_expressions
);
2453 add_info ("address", address_info
,
2454 _("Describe where symbol SYM is stored."));
2456 add_info ("symbol", sym_info
, _("\
2457 Describe what symbol is at location ADDR.\n\
2458 Only for symbols with fixed locations (global or static scope)."));
2460 add_com ("x", class_vars
, x_command
, _("\
2461 Examine memory: x/FMT ADDRESS.\n\
2462 ADDRESS is an expression for the memory address to examine.\n\
2463 FMT is a repeat count followed by a format letter and a size letter.\n\
2464 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2465 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n\
2466 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2467 The specified number of objects of the specified size are printed\n\
2468 according to the format.\n\n\
2469 Defaults for format and size letters are those previously used.\n\
2470 Default count is 1. Default address is following last thing printed\n\
2471 with this command or \"print\"."));
2474 add_com ("whereis", class_vars
, whereis_command
,
2475 _("Print line number and file of definition of variable."));
2478 add_info ("display", display_info
, _("\
2479 Expressions to display when program stops, with code numbers."));
2481 add_cmd ("undisplay", class_vars
, undisplay_command
, _("\
2482 Cancel some expressions to be displayed when program stops.\n\
2483 Arguments are the code numbers of the expressions to stop displaying.\n\
2484 No argument means cancel all automatic-display expressions.\n\
2485 \"delete display\" has the same effect as this command.\n\
2486 Do \"info display\" to see current list of code numbers."),
2489 add_com ("display", class_vars
, display_command
, _("\
2490 Print value of expression EXP each time the program stops.\n\
2491 /FMT may be used before EXP as in the \"print\" command.\n\
2492 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2493 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2494 and examining is done as in the \"x\" command.\n\n\
2495 With no argument, display all currently requested auto-display expressions.\n\
2496 Use \"undisplay\" to cancel display requests previously made."));
2498 add_cmd ("display", class_vars
, enable_display_command
, _("\
2499 Enable some expressions to be displayed when program stops.\n\
2500 Arguments are the code numbers of the expressions to resume displaying.\n\
2501 No argument means enable all automatic-display expressions.\n\
2502 Do \"info display\" to see current list of code numbers."), &enablelist
);
2504 add_cmd ("display", class_vars
, disable_display_command
, _("\
2505 Disable some expressions to be displayed when program stops.\n\
2506 Arguments are the code numbers of the expressions to stop displaying.\n\
2507 No argument means disable all automatic-display expressions.\n\
2508 Do \"info display\" to see current list of code numbers."), &disablelist
);
2510 add_cmd ("display", class_vars
, undisplay_command
, _("\
2511 Cancel some expressions to be displayed when program stops.\n\
2512 Arguments are the code numbers of the expressions to stop displaying.\n\
2513 No argument means cancel all automatic-display expressions.\n\
2514 Do \"info display\" to see current list of code numbers."), &deletelist
);
2516 add_com ("printf", class_vars
, printf_command
, _("\
2517 printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2518 This is useful for formatted output in user-defined commands."));
2520 add_com ("output", class_vars
, output_command
, _("\
2521 Like \"print\" but don't put in value history and don't print newline.\n\
2522 This is useful in user-defined commands."));
2524 add_prefix_cmd ("set", class_vars
, set_command
, _("\
2525 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2526 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2527 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2528 with $), a register (a few standard names starting with $), or an actual\n\
2529 variable in the program being debugged. EXP is any valid expression.\n\
2530 Use \"set variable\" for variables with names identical to set subcommands.\n\
2532 With a subcommand, this command modifies parts of the gdb environment.\n\
2533 You can see these environment settings with the \"show\" command."),
2534 &setlist
, "set ", 1, &cmdlist
);
2536 add_com ("assign", class_vars
, set_command
, _("\
2537 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2538 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2539 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2540 with $), a register (a few standard names starting with $), or an actual\n\
2541 variable in the program being debugged. EXP is any valid expression.\n\
2542 Use \"set variable\" for variables with names identical to set subcommands.\n\
2543 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2544 You can see these environment settings with the \"show\" command."));
2546 /* "call" is the same as "set", but handy for dbx users to call fns. */
2547 c
= add_com ("call", class_vars
, call_command
, _("\
2548 Call a function in the program.\n\
2549 The argument is the function name and arguments, in the notation of the\n\
2550 current working language. The result is printed and saved in the value\n\
2551 history, if it is not void."));
2552 set_cmd_completer (c
, expression_completer
);
2554 add_cmd ("variable", class_vars
, set_command
, _("\
2555 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2556 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2557 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2558 with $), a register (a few standard names starting with $), or an actual\n\
2559 variable in the program being debugged. EXP is any valid expression.\n\
2560 This may usually be abbreviated to simply \"set\"."),
2563 c
= add_com ("print", class_vars
, print_command
, _("\
2564 Print value of expression EXP.\n\
2565 Variables accessible are those of the lexical environment of the selected\n\
2566 stack frame, plus all those whose scope is global or an entire file.\n\
2568 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2569 $$NUM refers to NUM'th value back from the last one.\n\
2570 Names starting with $ refer to registers (with the values they would have\n\
2571 if the program were to return to the stack frame now selected, restoring\n\
2572 all registers saved by frames farther in) or else to debugger\n\
2573 \"convenience\" variables (any such name not a known register).\n\
2574 Use assignment expressions to give values to convenience variables.\n\
2576 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2577 @ is a binary operator for treating consecutive data objects\n\
2578 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2579 element is FOO, whose second element is stored in the space following\n\
2580 where FOO is stored, etc. FOO must be an expression whose value\n\
2581 resides in memory.\n\
2583 EXP may be preceded with /FMT, where FMT is a format letter\n\
2584 but no count or size letter (see \"x\" command)."));
2585 set_cmd_completer (c
, expression_completer
);
2586 add_com_alias ("p", "print", class_vars
, 1);
2587 add_com_alias ("inspect", "print", class_vars
, 1);
2589 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class
,
2590 &max_symbolic_offset
, _("\
2591 Set the largest offset that will be printed in <symbol+1234> form."), _("\
2592 Show the largest offset that will be printed in <symbol+1234> form."), NULL
,
2594 show_max_symbolic_offset
,
2595 &setprintlist
, &showprintlist
);
2596 add_setshow_boolean_cmd ("symbol-filename", no_class
,
2597 &print_symbol_filename
, _("\
2598 Set printing of source filename and line number with <symbol>."), _("\
2599 Show printing of source filename and line number with <symbol>."), NULL
,
2601 show_print_symbol_filename
,
2602 &setprintlist
, &showprintlist
);
2604 add_com ("eval", no_class
, eval_command
, _("\
2605 Convert \"printf format string\", arg1, arg2, arg3, ..., argn to\n\
2606 a command line, and call it."));