1 /* Print values for GNU debugger GDB.
3 Copyright (C) 1986-2020 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/>. */
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 */
42 #include "target-float.h"
43 #include "observable.h"
45 #include "parser-defs.h"
47 #include "arch-utils.h"
48 #include "cli/cli-utils.h"
49 #include "cli/cli-option.h"
50 #include "cli/cli-script.h"
51 #include "cli/cli-style.h"
52 #include "gdbsupport/format.h"
54 #include "gdbsupport/byte-vector.h"
55 #include "gdbsupport/gdb_optional.h"
57 /* Last specified output format. */
59 static char last_format
= 0;
61 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
63 static char last_size
= 'w';
65 /* Last specified count for the 'x' command. */
67 static int last_count
;
69 /* Default address to examine next, and associated architecture. */
71 static struct gdbarch
*next_gdbarch
;
72 static CORE_ADDR next_address
;
74 /* Number of delay instructions following current disassembled insn. */
76 static int branch_delay_insns
;
78 /* Last address examined. */
80 static CORE_ADDR last_examine_address
;
82 /* Contents of last address examined.
83 This is not valid past the end of the `x' command! */
85 static value_ref_ptr last_examine_value
;
87 /* Largest offset between a symbolic value and an address, that will be
88 printed as `0x1234 <symbol+offset>'. */
90 static unsigned int max_symbolic_offset
= UINT_MAX
;
92 show_max_symbolic_offset (struct ui_file
*file
, int from_tty
,
93 struct cmd_list_element
*c
, const char *value
)
95 fprintf_filtered (file
,
96 _("The largest offset that will be "
97 "printed in <symbol+1234> form is %s.\n"),
101 /* Append the source filename and linenumber of the symbol when
102 printing a symbolic value as `<symbol at filename:linenum>' if set. */
103 static bool print_symbol_filename
= false;
105 show_print_symbol_filename (struct ui_file
*file
, int from_tty
,
106 struct cmd_list_element
*c
, const char *value
)
108 fprintf_filtered (file
, _("Printing of source filename and "
109 "line number with <symbol> is %s.\n"),
113 /* Number of auto-display expression currently being displayed.
114 So that we can disable it if we get a signal within it.
115 -1 when not doing one. */
117 static int current_display_number
;
119 /* Last allocated display number. */
121 static int display_number
;
125 display (const char *exp_string_
, expression_up
&&exp_
,
126 const struct format_data
&format_
, struct program_space
*pspace_
,
127 const struct block
*block_
)
128 : exp_string (exp_string_
),
129 exp (std::move (exp_
)),
130 number (++display_number
),
138 /* The expression as the user typed it. */
139 std::string exp_string
;
141 /* Expression to be evaluated and displayed. */
144 /* Item number of this auto-display item. */
147 /* Display format specified. */
148 struct format_data format
;
150 /* Program space associated with `block'. */
151 struct program_space
*pspace
;
153 /* Innermost block required by this expression when evaluated. */
154 const struct block
*block
;
156 /* Status of this display (enabled or disabled). */
160 /* Expressions whose values should be displayed automatically each
161 time the program stops. */
163 static std::vector
<std::unique_ptr
<struct display
>> all_displays
;
165 /* Prototypes for local functions. */
167 static void do_one_display (struct display
*);
170 /* Decode a format specification. *STRING_PTR should point to it.
171 OFORMAT and OSIZE are used as defaults for the format and size
172 if none are given in the format specification.
173 If OSIZE is zero, then the size field of the returned value
174 should be set only if a size is explicitly specified by the
176 The structure returned describes all the data
177 found in the specification. In addition, *STRING_PTR is advanced
178 past the specification and past all whitespace following it. */
180 static struct format_data
181 decode_format (const char **string_ptr
, int oformat
, int osize
)
183 struct format_data val
;
184 const char *p
= *string_ptr
;
196 if (*p
>= '0' && *p
<= '9')
197 val
.count
*= atoi (p
);
198 while (*p
>= '0' && *p
<= '9')
201 /* Now process size or format letters that follow. */
205 if (*p
== 'b' || *p
== 'h' || *p
== 'w' || *p
== 'g')
212 else if (*p
>= 'a' && *p
<= 'z')
218 *string_ptr
= skip_spaces (p
);
220 /* Set defaults for format and size if not specified. */
221 if (val
.format
== '?')
225 /* Neither has been specified. */
226 val
.format
= oformat
;
230 /* If a size is specified, any format makes a reasonable
231 default except 'i'. */
232 val
.format
= oformat
== 'i' ? 'x' : oformat
;
234 else if (val
.size
== '?')
238 /* Pick the appropriate size for an address. This is deferred
239 until do_examine when we know the actual architecture to use.
240 A special size value of 'a' is used to indicate this case. */
241 val
.size
= osize
? 'a' : osize
;
244 /* Floating point has to be word or giantword. */
245 if (osize
== 'w' || osize
== 'g')
248 /* Default it to giantword if the last used size is not
250 val
.size
= osize
? 'g' : osize
;
253 /* Characters default to one byte. */
254 val
.size
= osize
? 'b' : osize
;
257 /* Display strings with byte size chars unless explicitly
263 /* The default is the size most recently specified. */
270 /* Print value VAL on stream according to OPTIONS.
271 Do not end with a newline.
272 SIZE is the letter for the size of datum being printed.
273 This is used to pad hex numbers so they line up. SIZE is 0
274 for print / output and set for examine. */
277 print_formatted (struct value
*val
, int size
,
278 const struct value_print_options
*options
,
279 struct ui_file
*stream
)
281 struct type
*type
= check_typedef (value_type (val
));
282 int len
= TYPE_LENGTH (type
);
284 if (VALUE_LVAL (val
) == lval_memory
)
285 next_address
= value_address (val
) + len
;
289 switch (options
->format
)
293 struct type
*elttype
= value_type (val
);
295 next_address
= (value_address (val
)
296 + val_print_string (elttype
, NULL
,
297 value_address (val
), -1,
298 stream
, options
) * len
);
303 /* We often wrap here if there are long symbolic names. */
305 next_address
= (value_address (val
)
306 + gdb_print_insn (get_type_arch (type
),
307 value_address (val
), stream
,
308 &branch_delay_insns
));
313 if (options
->format
== 0 || options
->format
== 's'
314 || type
->code () == TYPE_CODE_REF
315 || type
->code () == TYPE_CODE_ARRAY
316 || type
->code () == TYPE_CODE_STRING
317 || type
->code () == TYPE_CODE_STRUCT
318 || type
->code () == TYPE_CODE_UNION
319 || type
->code () == TYPE_CODE_NAMESPACE
)
320 value_print (val
, stream
, options
);
322 /* User specified format, so don't look to the type to tell us
324 value_print_scalar_formatted (val
, options
, size
, stream
);
327 /* Return builtin floating point type of same length as TYPE.
328 If no such type is found, return TYPE itself. */
330 float_type_from_length (struct type
*type
)
332 struct gdbarch
*gdbarch
= get_type_arch (type
);
333 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
335 if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_float
))
336 type
= builtin
->builtin_float
;
337 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_double
))
338 type
= builtin
->builtin_double
;
339 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_long_double
))
340 type
= builtin
->builtin_long_double
;
345 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
346 according to OPTIONS and SIZE on STREAM. Formats s and i are not
347 supported at this level. */
350 print_scalar_formatted (const gdb_byte
*valaddr
, struct type
*type
,
351 const struct value_print_options
*options
,
352 int size
, struct ui_file
*stream
)
354 struct gdbarch
*gdbarch
= get_type_arch (type
);
355 unsigned int len
= TYPE_LENGTH (type
);
356 enum bfd_endian byte_order
= type_byte_order (type
);
358 /* String printing should go through val_print_scalar_formatted. */
359 gdb_assert (options
->format
!= 's');
361 /* If the value is a pointer, and pointers and addresses are not the
362 same, then at this point, the value's length (in target bytes) is
363 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
364 if (type
->code () == TYPE_CODE_PTR
)
365 len
= gdbarch_addr_bit (gdbarch
) / TARGET_CHAR_BIT
;
367 /* If we are printing it as unsigned, truncate it in case it is actually
368 a negative signed value (e.g. "print/u (short)-1" should print 65535
369 (if shorts are 16 bits) instead of 4294967295). */
370 if (options
->format
!= 'c'
371 && (options
->format
!= 'd' || TYPE_UNSIGNED (type
)))
373 if (len
< TYPE_LENGTH (type
) && byte_order
== BFD_ENDIAN_BIG
)
374 valaddr
+= TYPE_LENGTH (type
) - len
;
377 if (size
!= 0 && (options
->format
== 'x' || options
->format
== 't'))
379 /* Truncate to fit. */
396 error (_("Undefined output size \"%c\"."), size
);
398 if (newlen
< len
&& byte_order
== BFD_ENDIAN_BIG
)
399 valaddr
+= len
- newlen
;
403 /* Historically gdb has printed floats by first casting them to a
404 long, and then printing the long. PR cli/16242 suggests changing
405 this to using C-style hex float format.
407 Biased range types must also be unbiased here; the unbiasing is
408 done by unpack_long. */
409 gdb::byte_vector converted_bytes
;
410 /* Some cases below will unpack the value again. In the biased
411 range case, we want to avoid this, so we store the unpacked value
412 here for possible use later. */
413 gdb::optional
<LONGEST
> val_long
;
414 if ((type
->code () == TYPE_CODE_FLT
415 && (options
->format
== 'o'
416 || options
->format
== 'x'
417 || options
->format
== 't'
418 || options
->format
== 'z'
419 || options
->format
== 'd'
420 || options
->format
== 'u'))
421 || (type
->code () == TYPE_CODE_RANGE
422 && TYPE_RANGE_DATA (type
)->bias
!= 0))
424 val_long
.emplace (unpack_long (type
, valaddr
));
425 converted_bytes
.resize (TYPE_LENGTH (type
));
426 store_signed_integer (converted_bytes
.data (), TYPE_LENGTH (type
),
427 byte_order
, *val_long
);
428 valaddr
= converted_bytes
.data ();
431 /* Printing a non-float type as 'f' will interpret the data as if it were
432 of a floating-point type of the same length, if that exists. Otherwise,
433 the data is printed as integer. */
434 char format
= options
->format
;
435 if (format
== 'f' && type
->code () != TYPE_CODE_FLT
)
437 type
= float_type_from_length (type
);
438 if (type
->code () != TYPE_CODE_FLT
)
445 print_octal_chars (stream
, valaddr
, len
, byte_order
);
448 print_decimal_chars (stream
, valaddr
, len
, true, byte_order
);
451 print_decimal_chars (stream
, valaddr
, len
, false, byte_order
);
454 if (type
->code () != TYPE_CODE_FLT
)
456 print_decimal_chars (stream
, valaddr
, len
, !TYPE_UNSIGNED (type
),
462 print_floating (valaddr
, type
, stream
);
466 print_binary_chars (stream
, valaddr
, len
, byte_order
, size
> 0);
469 print_hex_chars (stream
, valaddr
, len
, byte_order
, size
> 0);
472 print_hex_chars (stream
, valaddr
, len
, byte_order
, true);
476 struct value_print_options opts
= *options
;
478 if (!val_long
.has_value ())
479 val_long
.emplace (unpack_long (type
, valaddr
));
482 if (TYPE_UNSIGNED (type
))
483 type
= builtin_type (gdbarch
)->builtin_true_unsigned_char
;
485 type
= builtin_type (gdbarch
)->builtin_true_char
;
487 value_print (value_from_longest (type
, *val_long
), stream
, &opts
);
493 if (!val_long
.has_value ())
494 val_long
.emplace (unpack_long (type
, valaddr
));
495 print_address (gdbarch
, *val_long
, stream
);
500 error (_("Undefined output format \"%c\"."), format
);
504 /* Specify default address for `x' command.
505 The `info lines' command uses this. */
508 set_next_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
510 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
512 next_gdbarch
= gdbarch
;
515 /* Make address available to the user as $_. */
516 set_internalvar (lookup_internalvar ("_"),
517 value_from_pointer (ptr_type
, addr
));
520 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
521 after LEADIN. Print nothing if no symbolic name is found nearby.
522 Optionally also print source file and line number, if available.
523 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
524 or to interpret it as a possible C++ name and convert it back to source
525 form. However note that DO_DEMANGLE can be overridden by the specific
526 settings of the demangle and asm_demangle variables. Returns
527 non-zero if anything was printed; zero otherwise. */
530 print_address_symbolic (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
531 struct ui_file
*stream
,
532 int do_demangle
, const char *leadin
)
534 std::string name
, filename
;
539 if (build_address_symbolic (gdbarch
, addr
, do_demangle
, false, &name
,
540 &offset
, &filename
, &line
, &unmapped
))
543 fputs_filtered (leadin
, stream
);
545 fputs_filtered ("<*", stream
);
547 fputs_filtered ("<", stream
);
548 fputs_styled (name
.c_str (), function_name_style
.style (), stream
);
550 fprintf_filtered (stream
, "%+d", offset
);
552 /* Append source filename and line number if desired. Give specific
553 line # of this addr, if we have it; else line # of the nearest symbol. */
554 if (print_symbol_filename
&& !filename
.empty ())
556 fputs_filtered (line
== -1 ? " in " : " at ", stream
);
557 fputs_styled (filename
.c_str (), file_name_style
.style (), stream
);
559 fprintf_filtered (stream
, ":%d", line
);
562 fputs_filtered ("*>", stream
);
564 fputs_filtered (">", stream
);
569 /* See valprint.h. */
572 build_address_symbolic (struct gdbarch
*gdbarch
,
573 CORE_ADDR addr
, /* IN */
574 bool do_demangle
, /* IN */
575 bool prefer_sym_over_minsym
, /* IN */
576 std::string
*name
, /* OUT */
577 int *offset
, /* OUT */
578 std::string
*filename
, /* OUT */
580 int *unmapped
) /* OUT */
582 struct bound_minimal_symbol msymbol
;
583 struct symbol
*symbol
;
584 CORE_ADDR name_location
= 0;
585 struct obj_section
*section
= NULL
;
586 const char *name_temp
= "";
588 /* Let's say it is mapped (not unmapped). */
591 /* Determine if the address is in an overlay, and whether it is
593 if (overlay_debugging
)
595 section
= find_pc_overlay (addr
);
596 if (pc_in_unmapped_range (addr
, section
))
599 addr
= overlay_mapped_address (addr
, section
);
603 /* Try to find the address in both the symbol table and the minsyms.
604 In most cases, we'll prefer to use the symbol instead of the
605 minsym. However, there are cases (see below) where we'll choose
606 to use the minsym instead. */
608 /* This is defective in the sense that it only finds text symbols. So
609 really this is kind of pointless--we should make sure that the
610 minimal symbols have everything we need (by changing that we could
611 save some memory, but for many debug format--ELF/DWARF or
612 anything/stabs--it would be inconvenient to eliminate those minimal
614 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
615 symbol
= find_pc_sect_function (addr
, section
);
619 /* If this is a function (i.e. a code address), strip out any
620 non-address bits. For instance, display a pointer to the
621 first instruction of a Thumb function as <function>; the
622 second instruction will be <function+2>, even though the
623 pointer is <function+3>. This matches the ISA behavior. */
624 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
626 name_location
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (symbol
));
627 if (do_demangle
|| asm_demangle
)
628 name_temp
= symbol
->print_name ();
630 name_temp
= symbol
->linkage_name ();
633 if (msymbol
.minsym
!= NULL
634 && MSYMBOL_HAS_SIZE (msymbol
.minsym
)
635 && MSYMBOL_SIZE (msymbol
.minsym
) == 0
636 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text
637 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text_gnu_ifunc
638 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_file_text
)
639 msymbol
.minsym
= NULL
;
641 if (msymbol
.minsym
!= NULL
)
643 /* Use the minsym if no symbol is found.
645 Additionally, use the minsym instead of a (found) symbol if
646 the following conditions all hold:
647 1) The prefer_sym_over_minsym flag is false.
648 2) The minsym address is identical to that of the address under
650 3) The symbol address is not identical to that of the address
651 under consideration. */
652 if (symbol
== NULL
||
653 (!prefer_sym_over_minsym
654 && BMSYMBOL_VALUE_ADDRESS (msymbol
) == addr
655 && name_location
!= addr
))
657 /* If this is a function (i.e. a code address), strip out any
658 non-address bits. For instance, display a pointer to the
659 first instruction of a Thumb function as <function>; the
660 second instruction will be <function+2>, even though the
661 pointer is <function+3>. This matches the ISA behavior. */
662 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_text
663 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_text_gnu_ifunc
664 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_text
665 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
666 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
669 name_location
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
670 if (do_demangle
|| asm_demangle
)
671 name_temp
= msymbol
.minsym
->print_name ();
673 name_temp
= msymbol
.minsym
->linkage_name ();
676 if (symbol
== NULL
&& msymbol
.minsym
== NULL
)
679 /* If the nearest symbol is too far away, don't print anything symbolic. */
681 /* For when CORE_ADDR is larger than unsigned int, we do math in
682 CORE_ADDR. But when we detect unsigned wraparound in the
683 CORE_ADDR math, we ignore this test and print the offset,
684 because addr+max_symbolic_offset has wrapped through the end
685 of the address space back to the beginning, giving bogus comparison. */
686 if (addr
> name_location
+ max_symbolic_offset
687 && name_location
+ max_symbolic_offset
> name_location
)
690 *offset
= (LONGEST
) addr
- name_location
;
694 if (print_symbol_filename
)
696 struct symtab_and_line sal
;
698 sal
= find_pc_sect_line (addr
, section
, 0);
702 *filename
= symtab_to_filename_for_display (sal
.symtab
);
710 /* Print address ADDR symbolically on STREAM.
711 First print it as a number. Then perhaps print
712 <SYMBOL + OFFSET> after the number. */
715 print_address (struct gdbarch
*gdbarch
,
716 CORE_ADDR addr
, struct ui_file
*stream
)
718 fputs_styled (paddress (gdbarch
, addr
), address_style
.style (), stream
);
719 print_address_symbolic (gdbarch
, addr
, stream
, asm_demangle
, " ");
722 /* Return a prefix for instruction address:
723 "=> " for current instruction, else " ". */
726 pc_prefix (CORE_ADDR addr
)
728 if (has_stack_frames ())
730 struct frame_info
*frame
;
733 frame
= get_selected_frame (NULL
);
734 if (get_frame_pc_if_available (frame
, &pc
) && pc
== addr
)
740 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
741 controls whether to print the symbolic name "raw" or demangled.
742 Return non-zero if anything was printed; zero otherwise. */
745 print_address_demangle (const struct value_print_options
*opts
,
746 struct gdbarch
*gdbarch
, CORE_ADDR addr
,
747 struct ui_file
*stream
, int do_demangle
)
749 if (opts
->addressprint
)
751 fputs_styled (paddress (gdbarch
, addr
), address_style
.style (), stream
);
752 print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, " ");
756 return print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, "");
762 /* Find the address of the instruction that is INST_COUNT instructions before
763 the instruction at ADDR.
764 Since some architectures have variable-length instructions, we can't just
765 simply subtract INST_COUNT * INSN_LEN from ADDR. Instead, we use line
766 number information to locate the nearest known instruction boundary,
767 and disassemble forward from there. If we go out of the symbol range
768 during disassembling, we return the lowest address we've got so far and
769 set the number of instructions read to INST_READ. */
772 find_instruction_backward (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
773 int inst_count
, int *inst_read
)
775 /* The vector PCS is used to store instruction addresses within
777 CORE_ADDR loop_start
, loop_end
, p
;
778 std::vector
<CORE_ADDR
> pcs
;
779 struct symtab_and_line sal
;
782 loop_start
= loop_end
= addr
;
784 /* In each iteration of the outer loop, we get a pc range that ends before
785 LOOP_START, then we count and store every instruction address of the range
786 iterated in the loop.
787 If the number of instructions counted reaches INST_COUNT, return the
788 stored address that is located INST_COUNT instructions back from ADDR.
789 If INST_COUNT is not reached, we subtract the number of counted
790 instructions from INST_COUNT, and go to the next iteration. */
794 sal
= find_pc_sect_line (loop_start
, NULL
, 1);
797 /* We reach here when line info is not available. In this case,
798 we print a message and just exit the loop. The return value
799 is calculated after the loop. */
800 printf_filtered (_("No line number information available "
803 print_address (gdbarch
, loop_start
- 1, gdb_stdout
);
804 printf_filtered ("\n");
808 loop_end
= loop_start
;
811 /* This loop pushes instruction addresses in the range from
812 LOOP_START to LOOP_END. */
813 for (p
= loop_start
; p
< loop_end
;)
816 p
+= gdb_insn_length (gdbarch
, p
);
819 inst_count
-= pcs
.size ();
820 *inst_read
+= pcs
.size ();
822 while (inst_count
> 0);
824 /* After the loop, the vector PCS has instruction addresses of the last
825 source line we processed, and INST_COUNT has a negative value.
826 We return the address at the index of -INST_COUNT in the vector for
828 Let's assume the following instruction addresses and run 'x/-4i 0x400e'.
838 find_instruction_backward is called with INST_COUNT = 4 and expected to
839 return 0x4001. When we reach here, INST_COUNT is set to -1 because
840 it was subtracted by 2 (from Line Y) and 3 (from Line X). The value
841 4001 is located at the index 1 of the last iterated line (= Line X),
842 which is simply calculated by -INST_COUNT.
843 The case when the length of PCS is 0 means that we reached an area for
844 which line info is not available. In such case, we return LOOP_START,
845 which was the lowest instruction address that had line info. */
846 p
= pcs
.size () > 0 ? pcs
[-inst_count
] : loop_start
;
848 /* INST_READ includes all instruction addresses in a pc range. Need to
849 exclude the beginning part up to the address we're returning. That
850 is, exclude {0x4000} in the example above. */
852 *inst_read
+= inst_count
;
857 /* Backward read LEN bytes of target memory from address MEMADDR + LEN,
858 placing the results in GDB's memory from MYADDR + LEN. Returns
859 a count of the bytes actually read. */
862 read_memory_backward (struct gdbarch
*gdbarch
,
863 CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
866 int nread
; /* Number of bytes actually read. */
868 /* First try a complete read. */
869 errcode
= target_read_memory (memaddr
, myaddr
, len
);
877 /* Loop, reading one byte at a time until we get as much as we can. */
880 for (nread
= 0; nread
< len
; ++nread
)
882 errcode
= target_read_memory (--memaddr
, --myaddr
, 1);
885 /* The read was unsuccessful, so exit the loop. */
886 printf_filtered (_("Cannot access memory at address %s\n"),
887 paddress (gdbarch
, memaddr
));
895 /* Returns true if X (which is LEN bytes wide) is the number zero. */
898 integer_is_zero (const gdb_byte
*x
, int len
)
902 while (i
< len
&& x
[i
] == 0)
907 /* Find the start address of a string in which ADDR is included.
908 Basically we search for '\0' and return the next address,
909 but if OPTIONS->PRINT_MAX is smaller than the length of a string,
910 we stop searching and return the address to print characters as many as
911 PRINT_MAX from the string. */
914 find_string_backward (struct gdbarch
*gdbarch
,
915 CORE_ADDR addr
, int count
, int char_size
,
916 const struct value_print_options
*options
,
917 int *strings_counted
)
919 const int chunk_size
= 0x20;
922 int chars_to_read
= chunk_size
;
923 int chars_counted
= 0;
924 int count_original
= count
;
925 CORE_ADDR string_start_addr
= addr
;
927 gdb_assert (char_size
== 1 || char_size
== 2 || char_size
== 4);
928 gdb::byte_vector
buffer (chars_to_read
* char_size
);
929 while (count
> 0 && read_error
== 0)
933 addr
-= chars_to_read
* char_size
;
934 chars_read
= read_memory_backward (gdbarch
, addr
, buffer
.data (),
935 chars_to_read
* char_size
);
936 chars_read
/= char_size
;
937 read_error
= (chars_read
== chars_to_read
) ? 0 : 1;
938 /* Searching for '\0' from the end of buffer in backward direction. */
939 for (i
= 0; i
< chars_read
&& count
> 0 ; ++i
, ++chars_counted
)
941 int offset
= (chars_to_read
- i
- 1) * char_size
;
943 if (integer_is_zero (&buffer
[offset
], char_size
)
944 || chars_counted
== options
->print_max
)
946 /* Found '\0' or reached print_max. As OFFSET is the offset to
947 '\0', we add CHAR_SIZE to return the start address of
950 string_start_addr
= addr
+ offset
+ char_size
;
956 /* Update STRINGS_COUNTED with the actual number of loaded strings. */
957 *strings_counted
= count_original
- count
;
961 /* In error case, STRING_START_ADDR is pointing to the string that
962 was last successfully loaded. Rewind the partially loaded string. */
963 string_start_addr
-= chars_counted
* char_size
;
966 return string_start_addr
;
969 /* Examine data at address ADDR in format FMT.
970 Fetch it from memory and print on gdb_stdout. */
973 do_examine (struct format_data fmt
, struct gdbarch
*gdbarch
, CORE_ADDR addr
)
978 struct type
*val_type
= NULL
;
981 struct value_print_options opts
;
982 int need_to_update_next_address
= 0;
983 CORE_ADDR addr_rewound
= 0;
988 next_gdbarch
= gdbarch
;
991 /* Instruction format implies fetch single bytes
992 regardless of the specified size.
993 The case of strings is handled in decode_format, only explicit
994 size operator are not changed to 'b'. */
1000 /* Pick the appropriate size for an address. */
1001 if (gdbarch_ptr_bit (next_gdbarch
) == 64)
1003 else if (gdbarch_ptr_bit (next_gdbarch
) == 32)
1005 else if (gdbarch_ptr_bit (next_gdbarch
) == 16)
1008 /* Bad value for gdbarch_ptr_bit. */
1009 internal_error (__FILE__
, __LINE__
,
1010 _("failed internal consistency check"));
1014 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1015 else if (size
== 'h')
1016 val_type
= builtin_type (next_gdbarch
)->builtin_int16
;
1017 else if (size
== 'w')
1018 val_type
= builtin_type (next_gdbarch
)->builtin_int32
;
1019 else if (size
== 'g')
1020 val_type
= builtin_type (next_gdbarch
)->builtin_int64
;
1024 struct type
*char_type
= NULL
;
1026 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
1027 if type is not found. */
1029 char_type
= builtin_type (next_gdbarch
)->builtin_char16
;
1030 else if (size
== 'w')
1031 char_type
= builtin_type (next_gdbarch
)->builtin_char32
;
1033 val_type
= char_type
;
1036 if (size
!= '\0' && size
!= 'b')
1037 warning (_("Unable to display strings with "
1038 "size '%c', using 'b' instead."), size
);
1040 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1049 if (format
== 's' || format
== 'i')
1052 get_formatted_print_options (&opts
, format
);
1056 /* This is the negative repeat count case.
1057 We rewind the address based on the given repeat count and format,
1058 then examine memory from there in forward direction. */
1063 next_address
= find_instruction_backward (gdbarch
, addr
, count
,
1066 else if (format
== 's')
1068 next_address
= find_string_backward (gdbarch
, addr
, count
,
1069 TYPE_LENGTH (val_type
),
1074 next_address
= addr
- count
* TYPE_LENGTH (val_type
);
1077 /* The following call to print_formatted updates next_address in every
1078 iteration. In backward case, we store the start address here
1079 and update next_address with it before exiting the function. */
1080 addr_rewound
= (format
== 's'
1081 ? next_address
- TYPE_LENGTH (val_type
)
1083 need_to_update_next_address
= 1;
1086 /* Print as many objects as specified in COUNT, at most maxelts per line,
1087 with the address of the next one at the start of each line. */
1093 fputs_filtered (pc_prefix (next_address
), gdb_stdout
);
1094 print_address (next_gdbarch
, next_address
, gdb_stdout
);
1095 printf_filtered (":");
1100 printf_filtered ("\t");
1101 /* Note that print_formatted sets next_address for the next
1103 last_examine_address
= next_address
;
1105 /* The value to be displayed is not fetched greedily.
1106 Instead, to avoid the possibility of a fetched value not
1107 being used, its retrieval is delayed until the print code
1108 uses it. When examining an instruction stream, the
1109 disassembler will perform its own memory fetch using just
1110 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
1111 the disassembler be modified so that LAST_EXAMINE_VALUE
1112 is left with the byte sequence from the last complete
1113 instruction fetched from memory? */
1115 = release_value (value_at_lazy (val_type
, next_address
));
1117 print_formatted (last_examine_value
.get (), size
, &opts
, gdb_stdout
);
1119 /* Display any branch delay slots following the final insn. */
1120 if (format
== 'i' && count
== 1)
1121 count
+= branch_delay_insns
;
1123 printf_filtered ("\n");
1126 if (need_to_update_next_address
)
1127 next_address
= addr_rewound
;
1131 validate_format (struct format_data fmt
, const char *cmdname
)
1134 error (_("Size letters are meaningless in \"%s\" command."), cmdname
);
1136 error (_("Item count other than 1 is meaningless in \"%s\" command."),
1138 if (fmt
.format
== 'i')
1139 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
1140 fmt
.format
, cmdname
);
1143 /* Parse print command format string into *OPTS and update *EXPP.
1144 CMDNAME should name the current command. */
1147 print_command_parse_format (const char **expp
, const char *cmdname
,
1148 value_print_options
*opts
)
1150 const char *exp
= *expp
;
1152 /* opts->raw value might already have been set by 'set print raw-values'
1153 or by using 'print -raw-values'.
1154 So, do not set opts->raw to 0, only set it to 1 if /r is given. */
1155 if (exp
&& *exp
== '/')
1160 fmt
= decode_format (&exp
, last_format
, 0);
1161 validate_format (fmt
, cmdname
);
1162 last_format
= fmt
.format
;
1164 opts
->format
= fmt
.format
;
1165 opts
->raw
= opts
->raw
|| fmt
.raw
;
1175 /* See valprint.h. */
1178 print_value (value
*val
, const value_print_options
&opts
)
1180 int histindex
= record_latest_value (val
);
1182 annotate_value_history_begin (histindex
, value_type (val
));
1184 printf_filtered ("$%d = ", histindex
);
1186 annotate_value_history_value ();
1188 print_formatted (val
, 0, &opts
, gdb_stdout
);
1189 printf_filtered ("\n");
1191 annotate_value_history_end ();
1194 /* Implementation of the "print" and "call" commands. */
1197 print_command_1 (const char *args
, int voidprint
)
1200 value_print_options print_opts
;
1202 get_user_print_options (&print_opts
);
1203 /* Override global settings with explicit options, if any. */
1204 auto group
= make_value_print_options_def_group (&print_opts
);
1205 gdb::option::process_options
1206 (&args
, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER
, group
);
1208 print_command_parse_format (&args
, "print", &print_opts
);
1210 const char *exp
= args
;
1212 if (exp
!= nullptr && *exp
)
1214 expression_up expr
= parse_expression (exp
);
1215 val
= evaluate_expression (expr
.get ());
1218 val
= access_value_history (0);
1220 if (voidprint
|| (val
&& value_type (val
) &&
1221 value_type (val
)->code () != TYPE_CODE_VOID
))
1222 print_value (val
, print_opts
);
1225 /* See valprint.h. */
1228 print_command_completer (struct cmd_list_element
*ignore
,
1229 completion_tracker
&tracker
,
1230 const char *text
, const char * /*word*/)
1232 const auto group
= make_value_print_options_def_group (nullptr);
1233 if (gdb::option::complete_options
1234 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER
, group
))
1237 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
1238 expression_completer (ignore
, tracker
, text
, word
);
1242 print_command (const char *exp
, int from_tty
)
1244 print_command_1 (exp
, 1);
1247 /* Same as print, except it doesn't print void results. */
1249 call_command (const char *exp
, int from_tty
)
1251 print_command_1 (exp
, 0);
1254 /* Implementation of the "output" command. */
1257 output_command (const char *exp
, int from_tty
)
1261 struct format_data fmt
;
1262 struct value_print_options opts
;
1267 if (exp
&& *exp
== '/')
1270 fmt
= decode_format (&exp
, 0, 0);
1271 validate_format (fmt
, "output");
1272 format
= fmt
.format
;
1275 expression_up expr
= parse_expression (exp
);
1277 val
= evaluate_expression (expr
.get ());
1279 annotate_value_begin (value_type (val
));
1281 get_formatted_print_options (&opts
, format
);
1283 print_formatted (val
, fmt
.size
, &opts
, gdb_stdout
);
1285 annotate_value_end ();
1288 gdb_flush (gdb_stdout
);
1292 set_command (const char *exp
, int from_tty
)
1294 expression_up expr
= parse_expression (exp
);
1296 if (expr
->nelts
>= 1)
1297 switch (expr
->elts
[0].opcode
)
1299 case UNOP_PREINCREMENT
:
1300 case UNOP_POSTINCREMENT
:
1301 case UNOP_PREDECREMENT
:
1302 case UNOP_POSTDECREMENT
:
1304 case BINOP_ASSIGN_MODIFY
:
1309 (_("Expression is not an assignment (and might have no effect)"));
1312 evaluate_expression (expr
.get ());
1316 info_symbol_command (const char *arg
, int from_tty
)
1318 struct minimal_symbol
*msymbol
;
1319 struct obj_section
*osect
;
1320 CORE_ADDR addr
, sect_addr
;
1322 unsigned int offset
;
1325 error_no_arg (_("address"));
1327 addr
= parse_and_eval_address (arg
);
1328 for (objfile
*objfile
: current_program_space
->objfiles ())
1329 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
1331 /* Only process each object file once, even if there's a separate
1333 if (objfile
->separate_debug_objfile_backlink
)
1336 sect_addr
= overlay_mapped_address (addr
, osect
);
1338 if (obj_section_addr (osect
) <= sect_addr
1339 && sect_addr
< obj_section_endaddr (osect
)
1341 = lookup_minimal_symbol_by_pc_section (sect_addr
,
1344 const char *obj_name
, *mapped
, *sec_name
, *msym_name
;
1345 const char *loc_string
;
1348 offset
= sect_addr
- MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
);
1349 mapped
= section_is_mapped (osect
) ? _("mapped") : _("unmapped");
1350 sec_name
= osect
->the_bfd_section
->name
;
1351 msym_name
= msymbol
->print_name ();
1353 /* Don't print the offset if it is zero.
1354 We assume there's no need to handle i18n of "sym + offset". */
1355 std::string string_holder
;
1358 string_holder
= string_printf ("%s + %u", msym_name
, offset
);
1359 loc_string
= string_holder
.c_str ();
1362 loc_string
= msym_name
;
1364 gdb_assert (osect
->objfile
&& objfile_name (osect
->objfile
));
1365 obj_name
= objfile_name (osect
->objfile
);
1367 if (current_program_space
->multi_objfile_p ())
1368 if (pc_in_unmapped_range (addr
, osect
))
1369 if (section_is_overlay (osect
))
1370 printf_filtered (_("%s in load address range of "
1371 "%s overlay section %s of %s\n"),
1372 loc_string
, mapped
, sec_name
, obj_name
);
1374 printf_filtered (_("%s in load address range of "
1375 "section %s of %s\n"),
1376 loc_string
, sec_name
, obj_name
);
1378 if (section_is_overlay (osect
))
1379 printf_filtered (_("%s in %s overlay section %s of %s\n"),
1380 loc_string
, mapped
, sec_name
, obj_name
);
1382 printf_filtered (_("%s in section %s of %s\n"),
1383 loc_string
, sec_name
, obj_name
);
1385 if (pc_in_unmapped_range (addr
, osect
))
1386 if (section_is_overlay (osect
))
1387 printf_filtered (_("%s in load address range of %s overlay "
1389 loc_string
, mapped
, sec_name
);
1392 (_("%s in load address range of section %s\n"),
1393 loc_string
, sec_name
);
1395 if (section_is_overlay (osect
))
1396 printf_filtered (_("%s in %s overlay section %s\n"),
1397 loc_string
, mapped
, sec_name
);
1399 printf_filtered (_("%s in section %s\n"),
1400 loc_string
, sec_name
);
1404 printf_filtered (_("No symbol matches %s.\n"), arg
);
1408 info_address_command (const char *exp
, int from_tty
)
1410 struct gdbarch
*gdbarch
;
1413 struct bound_minimal_symbol msymbol
;
1415 struct obj_section
*section
;
1416 CORE_ADDR load_addr
, context_pc
= 0;
1417 struct field_of_this_result is_a_field_of_this
;
1420 error (_("Argument required."));
1422 sym
= lookup_symbol (exp
, get_selected_block (&context_pc
), VAR_DOMAIN
,
1423 &is_a_field_of_this
).symbol
;
1426 if (is_a_field_of_this
.type
!= NULL
)
1428 printf_filtered ("Symbol \"");
1429 fprintf_symbol_filtered (gdb_stdout
, exp
,
1430 current_language
->la_language
, DMGL_ANSI
);
1431 printf_filtered ("\" is a field of the local class variable ");
1432 if (current_language
->la_language
== language_objc
)
1433 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1435 printf_filtered ("`this'\n");
1439 msymbol
= lookup_bound_minimal_symbol (exp
);
1441 if (msymbol
.minsym
!= NULL
)
1443 struct objfile
*objfile
= msymbol
.objfile
;
1445 gdbarch
= objfile
->arch ();
1446 load_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
1448 printf_filtered ("Symbol \"");
1449 fprintf_symbol_filtered (gdb_stdout
, exp
,
1450 current_language
->la_language
, DMGL_ANSI
);
1451 printf_filtered ("\" is at ");
1452 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1454 printf_filtered (" in a file compiled without debugging");
1455 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
1456 if (section_is_overlay (section
))
1458 load_addr
= overlay_unmapped_address (load_addr
, section
);
1459 printf_filtered (",\n -- loaded at ");
1460 fputs_styled (paddress (gdbarch
, load_addr
),
1461 address_style
.style (),
1463 printf_filtered (" in overlay section %s",
1464 section
->the_bfd_section
->name
);
1466 printf_filtered (".\n");
1469 error (_("No symbol \"%s\" in current context."), exp
);
1473 printf_filtered ("Symbol \"");
1474 fprintf_symbol_filtered (gdb_stdout
, sym
->print_name (),
1475 current_language
->la_language
, DMGL_ANSI
);
1476 printf_filtered ("\" is ");
1477 val
= SYMBOL_VALUE (sym
);
1478 if (SYMBOL_OBJFILE_OWNED (sym
))
1479 section
= SYMBOL_OBJ_SECTION (symbol_objfile (sym
), sym
);
1482 gdbarch
= symbol_arch (sym
);
1484 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
1486 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, context_pc
,
1488 printf_filtered (".\n");
1492 switch (SYMBOL_CLASS (sym
))
1495 case LOC_CONST_BYTES
:
1496 printf_filtered ("constant");
1500 printf_filtered ("a label at address ");
1501 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1502 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1504 if (section_is_overlay (section
))
1506 load_addr
= overlay_unmapped_address (load_addr
, section
);
1507 printf_filtered (",\n -- loaded at ");
1508 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1510 printf_filtered (" in overlay section %s",
1511 section
->the_bfd_section
->name
);
1516 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
1519 /* GDBARCH is the architecture associated with the objfile the symbol
1520 is defined in; the target architecture may be different, and may
1521 provide additional registers. However, we do not know the target
1522 architecture at this point. We assume the objfile architecture
1523 will contain all the standard registers that occur in debug info
1525 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1527 if (SYMBOL_IS_ARGUMENT (sym
))
1528 printf_filtered (_("an argument in register %s"),
1529 gdbarch_register_name (gdbarch
, regno
));
1531 printf_filtered (_("a variable in register %s"),
1532 gdbarch_register_name (gdbarch
, regno
));
1536 printf_filtered (_("static storage at address "));
1537 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1538 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1540 if (section_is_overlay (section
))
1542 load_addr
= overlay_unmapped_address (load_addr
, section
);
1543 printf_filtered (_(",\n -- loaded at "));
1544 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1546 printf_filtered (_(" in overlay section %s"),
1547 section
->the_bfd_section
->name
);
1551 case LOC_REGPARM_ADDR
:
1552 /* Note comment at LOC_REGISTER. */
1553 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1554 printf_filtered (_("address of an argument in register %s"),
1555 gdbarch_register_name (gdbarch
, regno
));
1559 printf_filtered (_("an argument at offset %ld"), val
);
1563 printf_filtered (_("a local variable at frame offset %ld"), val
);
1567 printf_filtered (_("a reference argument at offset %ld"), val
);
1571 printf_filtered (_("a typedef"));
1575 printf_filtered (_("a function at address "));
1576 load_addr
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
1577 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1579 if (section_is_overlay (section
))
1581 load_addr
= overlay_unmapped_address (load_addr
, section
);
1582 printf_filtered (_(",\n -- loaded at "));
1583 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1585 printf_filtered (_(" in overlay section %s"),
1586 section
->the_bfd_section
->name
);
1590 case LOC_UNRESOLVED
:
1592 struct bound_minimal_symbol msym
;
1594 msym
= lookup_bound_minimal_symbol (sym
->linkage_name ());
1595 if (msym
.minsym
== NULL
)
1596 printf_filtered ("unresolved");
1599 section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
1602 && (section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
1604 load_addr
= MSYMBOL_VALUE_RAW_ADDRESS (msym
.minsym
);
1605 printf_filtered (_("a thread-local variable at offset %s "
1606 "in the thread-local storage for `%s'"),
1607 paddress (gdbarch
, load_addr
),
1608 objfile_name (section
->objfile
));
1612 load_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
1613 printf_filtered (_("static storage at address "));
1614 fputs_styled (paddress (gdbarch
, load_addr
),
1615 address_style
.style (), gdb_stdout
);
1616 if (section_is_overlay (section
))
1618 load_addr
= overlay_unmapped_address (load_addr
, section
);
1619 printf_filtered (_(",\n -- loaded at "));
1620 fputs_styled (paddress (gdbarch
, load_addr
),
1621 address_style
.style (),
1623 printf_filtered (_(" in overlay section %s"),
1624 section
->the_bfd_section
->name
);
1631 case LOC_OPTIMIZED_OUT
:
1632 printf_filtered (_("optimized out"));
1636 printf_filtered (_("of unknown (botched) type"));
1639 printf_filtered (".\n");
1644 x_command (const char *exp
, int from_tty
)
1646 struct format_data fmt
;
1649 fmt
.format
= last_format
? last_format
: 'x';
1650 fmt
.size
= last_size
;
1654 /* If there is no expression and no format, use the most recent
1656 if (exp
== nullptr && last_count
> 0)
1657 fmt
.count
= last_count
;
1659 if (exp
&& *exp
== '/')
1661 const char *tmp
= exp
+ 1;
1663 fmt
= decode_format (&tmp
, last_format
, last_size
);
1667 last_count
= fmt
.count
;
1669 /* If we have an expression, evaluate it and use it as the address. */
1671 if (exp
!= 0 && *exp
!= 0)
1673 expression_up expr
= parse_expression (exp
);
1674 /* Cause expression not to be there any more if this command is
1675 repeated with Newline. But don't clobber a user-defined
1676 command's definition. */
1678 set_repeat_arguments ("");
1679 val
= evaluate_expression (expr
.get ());
1680 if (TYPE_IS_REFERENCE (value_type (val
)))
1681 val
= coerce_ref (val
);
1682 /* In rvalue contexts, such as this, functions are coerced into
1683 pointers to functions. This makes "x/i main" work. */
1684 if (value_type (val
)->code () == TYPE_CODE_FUNC
1685 && VALUE_LVAL (val
) == lval_memory
)
1686 next_address
= value_address (val
);
1688 next_address
= value_as_address (val
);
1690 next_gdbarch
= expr
->gdbarch
;
1694 error_no_arg (_("starting display address"));
1696 do_examine (fmt
, next_gdbarch
, next_address
);
1698 /* If the examine succeeds, we remember its size and format for next
1699 time. Set last_size to 'b' for strings. */
1700 if (fmt
.format
== 's')
1703 last_size
= fmt
.size
;
1704 last_format
= fmt
.format
;
1706 /* Set a couple of internal variables if appropriate. */
1707 if (last_examine_value
!= nullptr)
1709 /* Make last address examined available to the user as $_. Use
1710 the correct pointer type. */
1711 struct type
*pointer_type
1712 = lookup_pointer_type (value_type (last_examine_value
.get ()));
1713 set_internalvar (lookup_internalvar ("_"),
1714 value_from_pointer (pointer_type
,
1715 last_examine_address
));
1717 /* Make contents of last address examined available to the user
1718 as $__. If the last value has not been fetched from memory
1719 then don't fetch it now; instead mark it by voiding the $__
1721 if (value_lazy (last_examine_value
.get ()))
1722 clear_internalvar (lookup_internalvar ("__"));
1724 set_internalvar (lookup_internalvar ("__"), last_examine_value
.get ());
1729 /* Add an expression to the auto-display chain.
1730 Specify the expression. */
1733 display_command (const char *arg
, int from_tty
)
1735 struct format_data fmt
;
1736 struct display
*newobj
;
1737 const char *exp
= arg
;
1748 fmt
= decode_format (&exp
, 0, 0);
1749 if (fmt
.size
&& fmt
.format
== 0)
1751 if (fmt
.format
== 'i' || fmt
.format
== 's')
1762 innermost_block_tracker tracker
;
1763 expression_up expr
= parse_expression (exp
, &tracker
);
1765 newobj
= new display (exp
, std::move (expr
), fmt
,
1766 current_program_space
, tracker
.block ());
1767 all_displays
.emplace_back (newobj
);
1770 do_one_display (newobj
);
1775 /* Clear out the display_chain. Done when new symtabs are loaded,
1776 since this invalidates the types stored in many expressions. */
1781 all_displays
.clear ();
1784 /* Delete the auto-display DISPLAY. */
1787 delete_display (struct display
*display
)
1789 gdb_assert (display
!= NULL
);
1791 auto iter
= std::find_if (all_displays
.begin (),
1792 all_displays
.end (),
1793 [=] (const std::unique_ptr
<struct display
> &item
)
1795 return item
.get () == display
;
1797 gdb_assert (iter
!= all_displays
.end ());
1798 all_displays
.erase (iter
);
1801 /* Call FUNCTION on each of the displays whose numbers are given in
1802 ARGS. DATA is passed unmodified to FUNCTION. */
1805 map_display_numbers (const char *args
,
1806 gdb::function_view
<void (struct display
*)> function
)
1811 error_no_arg (_("one or more display numbers"));
1813 number_or_range_parser
parser (args
);
1815 while (!parser
.finished ())
1817 const char *p
= parser
.cur_tok ();
1819 num
= parser
.get_number ();
1821 warning (_("bad display number at or near '%s'"), p
);
1824 auto iter
= std::find_if (all_displays
.begin (),
1825 all_displays
.end (),
1826 [=] (const std::unique_ptr
<display
> &item
)
1828 return item
->number
== num
;
1830 if (iter
== all_displays
.end ())
1831 printf_unfiltered (_("No display number %d.\n"), num
);
1833 function (iter
->get ());
1838 /* "undisplay" command. */
1841 undisplay_command (const char *args
, int from_tty
)
1845 if (query (_("Delete all auto-display expressions? ")))
1851 map_display_numbers (args
, delete_display
);
1855 /* Display a single auto-display.
1856 Do nothing if the display cannot be printed in the current context,
1857 or if the display is disabled. */
1860 do_one_display (struct display
*d
)
1862 int within_current_scope
;
1867 /* The expression carries the architecture that was used at parse time.
1868 This is a problem if the expression depends on architecture features
1869 (e.g. register numbers), and the current architecture is now different.
1870 For example, a display statement like "display/i $pc" is expected to
1871 display the PC register of the current architecture, not the arch at
1872 the time the display command was given. Therefore, we re-parse the
1873 expression if the current architecture has changed. */
1874 if (d
->exp
!= NULL
&& d
->exp
->gdbarch
!= get_current_arch ())
1885 innermost_block_tracker tracker
;
1886 d
->exp
= parse_expression (d
->exp_string
.c_str (), &tracker
);
1887 d
->block
= tracker
.block ();
1889 catch (const gdb_exception
&ex
)
1891 /* Can't re-parse the expression. Disable this display item. */
1892 d
->enabled_p
= false;
1893 warning (_("Unable to display \"%s\": %s"),
1894 d
->exp_string
.c_str (), ex
.what ());
1901 if (d
->pspace
== current_program_space
)
1902 within_current_scope
= contained_in (get_selected_block (0), d
->block
,
1905 within_current_scope
= 0;
1908 within_current_scope
= 1;
1909 if (!within_current_scope
)
1912 scoped_restore save_display_number
1913 = make_scoped_restore (¤t_display_number
, d
->number
);
1915 annotate_display_begin ();
1916 printf_filtered ("%d", d
->number
);
1917 annotate_display_number_end ();
1918 printf_filtered (": ");
1922 annotate_display_format ();
1924 printf_filtered ("x/");
1925 if (d
->format
.count
!= 1)
1926 printf_filtered ("%d", d
->format
.count
);
1927 printf_filtered ("%c", d
->format
.format
);
1928 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1929 printf_filtered ("%c", d
->format
.size
);
1930 printf_filtered (" ");
1932 annotate_display_expression ();
1934 puts_filtered (d
->exp_string
.c_str ());
1935 annotate_display_expression_end ();
1937 if (d
->format
.count
!= 1 || d
->format
.format
== 'i')
1938 printf_filtered ("\n");
1940 printf_filtered (" ");
1942 annotate_display_value ();
1949 val
= evaluate_expression (d
->exp
.get ());
1950 addr
= value_as_address (val
);
1951 if (d
->format
.format
== 'i')
1952 addr
= gdbarch_addr_bits_remove (d
->exp
->gdbarch
, addr
);
1953 do_examine (d
->format
, d
->exp
->gdbarch
, addr
);
1955 catch (const gdb_exception_error
&ex
)
1957 fprintf_filtered (gdb_stdout
, _("%p[<error: %s>%p]\n"),
1958 metadata_style
.style ().ptr (), ex
.what (),
1964 struct value_print_options opts
;
1966 annotate_display_format ();
1968 if (d
->format
.format
)
1969 printf_filtered ("/%c ", d
->format
.format
);
1971 annotate_display_expression ();
1973 puts_filtered (d
->exp_string
.c_str ());
1974 annotate_display_expression_end ();
1976 printf_filtered (" = ");
1978 annotate_display_expression ();
1980 get_formatted_print_options (&opts
, d
->format
.format
);
1981 opts
.raw
= d
->format
.raw
;
1987 val
= evaluate_expression (d
->exp
.get ());
1988 print_formatted (val
, d
->format
.size
, &opts
, gdb_stdout
);
1990 catch (const gdb_exception_error
&ex
)
1992 fprintf_styled (gdb_stdout
, metadata_style
.style (),
1993 _("<error: %s>"), ex
.what ());
1996 printf_filtered ("\n");
1999 annotate_display_end ();
2001 gdb_flush (gdb_stdout
);
2004 /* Display all of the values on the auto-display chain which can be
2005 evaluated in the current scope. */
2010 for (auto &d
: all_displays
)
2011 do_one_display (d
.get ());
2014 /* Delete the auto-display which we were in the process of displaying.
2015 This is done when there is an error or a signal. */
2018 disable_display (int num
)
2020 for (auto &d
: all_displays
)
2021 if (d
->number
== num
)
2023 d
->enabled_p
= false;
2026 printf_unfiltered (_("No display number %d.\n"), num
);
2030 disable_current_display (void)
2032 if (current_display_number
>= 0)
2034 disable_display (current_display_number
);
2035 fprintf_unfiltered (gdb_stderr
,
2036 _("Disabling display %d to "
2037 "avoid infinite recursion.\n"),
2038 current_display_number
);
2040 current_display_number
= -1;
2044 info_display_command (const char *ignore
, int from_tty
)
2046 if (all_displays
.empty ())
2047 printf_unfiltered (_("There are no auto-display expressions now.\n"));
2049 printf_filtered (_("Auto-display expressions now in effect:\n\
2050 Num Enb Expression\n"));
2052 for (auto &d
: all_displays
)
2054 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
2056 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
2058 else if (d
->format
.format
)
2059 printf_filtered ("/%c ", d
->format
.format
);
2060 puts_filtered (d
->exp_string
.c_str ());
2061 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
, true))
2062 printf_filtered (_(" (cannot be evaluated in the current context)"));
2063 printf_filtered ("\n");
2067 /* Implementation of both the "disable display" and "enable display"
2068 commands. ENABLE decides what to do. */
2071 enable_disable_display_command (const char *args
, int from_tty
, bool enable
)
2075 for (auto &d
: all_displays
)
2076 d
->enabled_p
= enable
;
2080 map_display_numbers (args
,
2081 [=] (struct display
*d
)
2083 d
->enabled_p
= enable
;
2087 /* The "enable display" command. */
2090 enable_display_command (const char *args
, int from_tty
)
2092 enable_disable_display_command (args
, from_tty
, true);
2095 /* The "disable display" command. */
2098 disable_display_command (const char *args
, int from_tty
)
2100 enable_disable_display_command (args
, from_tty
, false);
2103 /* display_chain items point to blocks and expressions. Some expressions in
2104 turn may point to symbols.
2105 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
2106 obstack_free'd when a shared library is unloaded.
2107 Clear pointers that are about to become dangling.
2108 Both .exp and .block fields will be restored next time we need to display
2109 an item by re-parsing .exp_string field in the new execution context. */
2112 clear_dangling_display_expressions (struct objfile
*objfile
)
2114 struct program_space
*pspace
;
2116 /* With no symbol file we cannot have a block or expression from it. */
2117 if (objfile
== NULL
)
2119 pspace
= objfile
->pspace
;
2120 if (objfile
->separate_debug_objfile_backlink
)
2122 objfile
= objfile
->separate_debug_objfile_backlink
;
2123 gdb_assert (objfile
->pspace
== pspace
);
2126 for (auto &d
: all_displays
)
2128 if (d
->pspace
!= pspace
)
2131 struct objfile
*bl_objf
= nullptr;
2132 if (d
->block
!= nullptr)
2134 bl_objf
= block_objfile (d
->block
);
2135 if (bl_objf
->separate_debug_objfile_backlink
!= nullptr)
2136 bl_objf
= bl_objf
->separate_debug_objfile_backlink
;
2139 if (bl_objf
== objfile
2140 || (d
->exp
!= NULL
&& exp_uses_objfile (d
->exp
.get (), objfile
)))
2149 /* Print the value in stack frame FRAME of a variable specified by a
2150 struct symbol. NAME is the name to print; if NULL then VAR's print
2151 name will be used. STREAM is the ui_file on which to print the
2152 value. INDENT specifies the number of indent levels to print
2153 before printing the variable name.
2155 This function invalidates FRAME. */
2158 print_variable_and_value (const char *name
, struct symbol
*var
,
2159 struct frame_info
*frame
,
2160 struct ui_file
*stream
, int indent
)
2164 name
= var
->print_name ();
2166 fprintf_filtered (stream
, "%s%ps = ", n_spaces (2 * indent
),
2167 styled_string (variable_name_style
.style (), name
));
2172 struct value_print_options opts
;
2174 /* READ_VAR_VALUE needs a block in order to deal with non-local
2175 references (i.e. to handle nested functions). In this context, we
2176 print variables that are local to this frame, so we can avoid passing
2178 val
= read_var_value (var
, NULL
, frame
);
2179 get_user_print_options (&opts
);
2181 common_val_print (val
, stream
, indent
, &opts
, current_language
);
2183 /* common_val_print invalidates FRAME when a pretty printer calls inferior
2187 catch (const gdb_exception_error
&except
)
2189 fprintf_styled (stream
, metadata_style
.style (),
2190 "<error reading variable %s (%s)>", name
,
2194 fprintf_filtered (stream
, "\n");
2197 /* Subroutine of ui_printf to simplify it.
2198 Print VALUE to STREAM using FORMAT.
2199 VALUE is a C-style string either on the target or
2200 in a GDB internal variable. */
2203 printf_c_string (struct ui_file
*stream
, const char *format
,
2204 struct value
*value
)
2206 const gdb_byte
*str
;
2208 if (value_type (value
)->code () != TYPE_CODE_PTR
2209 && VALUE_LVAL (value
) == lval_internalvar
2210 && c_is_string_type_p (value_type (value
)))
2212 size_t len
= TYPE_LENGTH (value_type (value
));
2214 /* Copy the internal var value to TEM_STR and append a terminating null
2215 character. This protects against corrupted C-style strings that lack
2216 the terminating null char. It also allows Ada-style strings (not
2217 null terminated) to be printed without problems. */
2218 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ 1);
2220 memcpy (tem_str
, value_contents (value
), len
);
2226 CORE_ADDR tem
= value_as_address (value
);;
2231 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2232 fprintf_filtered (stream
, format
, "(null)");
2237 /* This is a %s argument. Find the length of the string. */
2240 for (len
= 0;; len
++)
2245 read_memory (tem
+ len
, &c
, 1);
2250 /* Copy the string contents into a string inside GDB. */
2251 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ 1);
2254 read_memory (tem
, tem_str
, len
);
2260 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2261 fprintf_filtered (stream
, format
, (char *) str
);
2265 /* Subroutine of ui_printf to simplify it.
2266 Print VALUE to STREAM using FORMAT.
2267 VALUE is a wide C-style string on the target or
2268 in a GDB internal variable. */
2271 printf_wide_c_string (struct ui_file
*stream
, const char *format
,
2272 struct value
*value
)
2274 const gdb_byte
*str
;
2276 struct gdbarch
*gdbarch
= get_type_arch (value_type (value
));
2277 struct type
*wctype
= lookup_typename (current_language
,
2278 "wchar_t", NULL
, 0);
2279 int wcwidth
= TYPE_LENGTH (wctype
);
2281 if (VALUE_LVAL (value
) == lval_internalvar
2282 && c_is_string_type_p (value_type (value
)))
2284 str
= value_contents (value
);
2285 len
= TYPE_LENGTH (value_type (value
));
2289 CORE_ADDR tem
= value_as_address (value
);
2294 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2295 fprintf_filtered (stream
, format
, "(null)");
2300 /* This is a %s argument. Find the length of the string. */
2301 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2302 gdb_byte
*buf
= (gdb_byte
*) alloca (wcwidth
);
2304 for (len
= 0;; len
+= wcwidth
)
2307 read_memory (tem
+ len
, buf
, wcwidth
);
2308 if (extract_unsigned_integer (buf
, wcwidth
, byte_order
) == 0)
2312 /* Copy the string contents into a string inside GDB. */
2313 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ wcwidth
);
2316 read_memory (tem
, tem_str
, len
);
2317 memset (&tem_str
[len
], 0, wcwidth
);
2321 auto_obstack output
;
2323 convert_between_encodings (target_wide_charset (gdbarch
),
2326 &output
, translit_char
);
2327 obstack_grow_str0 (&output
, "");
2330 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2331 fprintf_filtered (stream
, format
, obstack_base (&output
));
2335 /* Subroutine of ui_printf to simplify it.
2336 Print VALUE, a floating point value, to STREAM using FORMAT. */
2339 printf_floating (struct ui_file
*stream
, const char *format
,
2340 struct value
*value
, enum argclass argclass
)
2342 /* Parameter data. */
2343 struct type
*param_type
= value_type (value
);
2344 struct gdbarch
*gdbarch
= get_type_arch (param_type
);
2346 /* Determine target type corresponding to the format string. */
2347 struct type
*fmt_type
;
2351 fmt_type
= builtin_type (gdbarch
)->builtin_double
;
2353 case long_double_arg
:
2354 fmt_type
= builtin_type (gdbarch
)->builtin_long_double
;
2356 case dec32float_arg
:
2357 fmt_type
= builtin_type (gdbarch
)->builtin_decfloat
;
2359 case dec64float_arg
:
2360 fmt_type
= builtin_type (gdbarch
)->builtin_decdouble
;
2362 case dec128float_arg
:
2363 fmt_type
= builtin_type (gdbarch
)->builtin_declong
;
2366 gdb_assert_not_reached ("unexpected argument class");
2369 /* To match the traditional GDB behavior, the conversion is
2370 done differently depending on the type of the parameter:
2372 - if the parameter has floating-point type, it's value
2373 is converted to the target type;
2375 - otherwise, if the parameter has a type that is of the
2376 same size as a built-in floating-point type, the value
2377 bytes are interpreted as if they were of that type, and
2378 then converted to the target type (this is not done for
2379 decimal floating-point argument classes);
2381 - otherwise, if the source value has an integer value,
2382 it's value is converted to the target type;
2384 - otherwise, an error is raised.
2386 In either case, the result of the conversion is a byte buffer
2387 formatted in the target format for the target type. */
2389 if (fmt_type
->code () == TYPE_CODE_FLT
)
2391 param_type
= float_type_from_length (param_type
);
2392 if (param_type
!= value_type (value
))
2393 value
= value_from_contents (param_type
, value_contents (value
));
2396 value
= value_cast (fmt_type
, value
);
2398 /* Convert the value to a string and print it. */
2400 = target_float_to_string (value_contents (value
), fmt_type
, format
);
2401 fputs_filtered (str
.c_str (), stream
);
2404 /* Subroutine of ui_printf to simplify it.
2405 Print VALUE, a target pointer, to STREAM using FORMAT. */
2408 printf_pointer (struct ui_file
*stream
, const char *format
,
2409 struct value
*value
)
2411 /* We avoid the host's %p because pointers are too
2412 likely to be the wrong size. The only interesting
2413 modifier for %p is a width; extract that, and then
2414 handle %p as glibc would: %#x or a literal "(nil)". */
2418 #ifdef PRINTF_HAS_LONG_LONG
2419 long long val
= value_as_long (value
);
2421 long val
= value_as_long (value
);
2424 fmt
= (char *) alloca (strlen (format
) + 5);
2426 /* Copy up to the leading %. */
2431 int is_percent
= (*p
== '%');
2446 /* Copy any width or flags. Only the "-" flag is valid for pointers
2447 -- see the format_pieces constructor. */
2448 while (*p
== '-' || (*p
>= '0' && *p
< '9'))
2451 gdb_assert (*p
== 'p' && *(p
+ 1) == '\0');
2454 #ifdef PRINTF_HAS_LONG_LONG
2461 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2462 fprintf_filtered (stream
, fmt
, val
);
2470 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2471 fprintf_filtered (stream
, fmt
, "(nil)");
2476 /* printf "printf format string" ARG to STREAM. */
2479 ui_printf (const char *arg
, struct ui_file
*stream
)
2481 const char *s
= arg
;
2482 std::vector
<struct value
*> val_args
;
2485 error_no_arg (_("format-control string and values to print"));
2487 s
= skip_spaces (s
);
2489 /* A format string should follow, enveloped in double quotes. */
2491 error (_("Bad format string, missing '\"'."));
2493 format_pieces
fpieces (&s
);
2496 error (_("Bad format string, non-terminated '\"'."));
2498 s
= skip_spaces (s
);
2500 if (*s
!= ',' && *s
!= 0)
2501 error (_("Invalid argument syntax"));
2505 s
= skip_spaces (s
);
2510 const char *current_substring
;
2513 for (auto &&piece
: fpieces
)
2514 if (piece
.argclass
!= literal_piece
)
2517 /* Now, parse all arguments and evaluate them.
2518 Store the VALUEs in VAL_ARGS. */
2525 val_args
.push_back (parse_to_comma_and_eval (&s1
));
2532 if (val_args
.size () != nargs_wanted
)
2533 error (_("Wrong number of arguments for specified format-string"));
2535 /* Now actually print them. */
2537 for (auto &&piece
: fpieces
)
2539 current_substring
= piece
.string
;
2540 switch (piece
.argclass
)
2543 printf_c_string (stream
, current_substring
, val_args
[i
]);
2545 case wide_string_arg
:
2546 printf_wide_c_string (stream
, current_substring
, val_args
[i
]);
2550 struct gdbarch
*gdbarch
2551 = get_type_arch (value_type (val_args
[i
]));
2552 struct type
*wctype
= lookup_typename (current_language
,
2553 "wchar_t", NULL
, 0);
2554 struct type
*valtype
;
2555 const gdb_byte
*bytes
;
2557 valtype
= value_type (val_args
[i
]);
2558 if (TYPE_LENGTH (valtype
) != TYPE_LENGTH (wctype
)
2559 || valtype
->code () != TYPE_CODE_INT
)
2560 error (_("expected wchar_t argument for %%lc"));
2562 bytes
= value_contents (val_args
[i
]);
2564 auto_obstack output
;
2566 convert_between_encodings (target_wide_charset (gdbarch
),
2568 bytes
, TYPE_LENGTH (valtype
),
2569 TYPE_LENGTH (valtype
),
2570 &output
, translit_char
);
2571 obstack_grow_str0 (&output
, "");
2574 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2575 fprintf_filtered (stream
, current_substring
,
2576 obstack_base (&output
));
2581 #ifdef PRINTF_HAS_LONG_LONG
2583 long long val
= value_as_long (val_args
[i
]);
2586 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2587 fprintf_filtered (stream
, current_substring
, val
);
2592 error (_("long long not supported in printf"));
2596 int val
= value_as_long (val_args
[i
]);
2599 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2600 fprintf_filtered (stream
, current_substring
, val
);
2606 long val
= value_as_long (val_args
[i
]);
2609 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2610 fprintf_filtered (stream
, current_substring
, val
);
2616 size_t val
= value_as_long (val_args
[i
]);
2619 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2620 fprintf_filtered (stream
, current_substring
, val
);
2624 /* Handles floating-point values. */
2626 case long_double_arg
:
2627 case dec32float_arg
:
2628 case dec64float_arg
:
2629 case dec128float_arg
:
2630 printf_floating (stream
, current_substring
, val_args
[i
],
2634 printf_pointer (stream
, current_substring
, val_args
[i
]);
2637 /* Print a portion of the format string that has no
2638 directives. Note that this will not include any
2639 ordinary %-specs, but it might include "%%". That is
2640 why we use printf_filtered and not puts_filtered here.
2641 Also, we pass a dummy argument because some platforms
2642 have modified GCC to include -Wformat-security by
2643 default, which will warn here if there is no
2646 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2647 fprintf_filtered (stream
, current_substring
, 0);
2651 internal_error (__FILE__
, __LINE__
,
2652 _("failed internal consistency check"));
2654 /* Maybe advance to the next argument. */
2655 if (piece
.argclass
!= literal_piece
)
2661 /* Implement the "printf" command. */
2664 printf_command (const char *arg
, int from_tty
)
2666 ui_printf (arg
, gdb_stdout
);
2667 reset_terminal_style (gdb_stdout
);
2669 gdb_stdout
->flush ();
2672 /* Implement the "eval" command. */
2675 eval_command (const char *arg
, int from_tty
)
2679 ui_printf (arg
, &stb
);
2681 std::string expanded
= insert_user_defined_cmd_args (stb
.c_str ());
2683 execute_command (expanded
.c_str (), from_tty
);
2686 void _initialize_printcmd ();
2688 _initialize_printcmd ()
2690 struct cmd_list_element
*c
;
2692 current_display_number
= -1;
2694 gdb::observers::free_objfile
.attach (clear_dangling_display_expressions
);
2696 add_info ("address", info_address_command
,
2697 _("Describe where symbol SYM is stored.\n\
2698 Usage: info address SYM"));
2700 add_info ("symbol", info_symbol_command
, _("\
2701 Describe what symbol is at location ADDR.\n\
2702 Usage: info symbol ADDR\n\
2703 Only for symbols with fixed locations (global or static scope)."));
2705 add_com ("x", class_vars
, x_command
, _("\
2706 Examine memory: x/FMT ADDRESS.\n\
2707 ADDRESS is an expression for the memory address to examine.\n\
2708 FMT is a repeat count followed by a format letter and a size letter.\n\
2709 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2710 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2711 and z(hex, zero padded on the left).\n\
2712 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2713 The specified number of objects of the specified size are printed\n\
2714 according to the format. If a negative number is specified, memory is\n\
2715 examined backward from the address.\n\n\
2716 Defaults for format and size letters are those previously used.\n\
2717 Default count is 1. Default address is following last thing printed\n\
2718 with this command or \"print\"."));
2720 add_info ("display", info_display_command
, _("\
2721 Expressions to display when program stops, with code numbers.\n\
2722 Usage: info display"));
2724 add_cmd ("undisplay", class_vars
, undisplay_command
, _("\
2725 Cancel some expressions to be displayed when program stops.\n\
2726 Usage: undisplay [NUM]...\n\
2727 Arguments are the code numbers of the expressions to stop displaying.\n\
2728 No argument means cancel all automatic-display expressions.\n\
2729 \"delete display\" has the same effect as this command.\n\
2730 Do \"info display\" to see current list of code numbers."),
2733 add_com ("display", class_vars
, display_command
, _("\
2734 Print value of expression EXP each time the program stops.\n\
2735 Usage: display[/FMT] EXP\n\
2736 /FMT may be used before EXP as in the \"print\" command.\n\
2737 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2738 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2739 and examining is done as in the \"x\" command.\n\n\
2740 With no argument, display all currently requested auto-display expressions.\n\
2741 Use \"undisplay\" to cancel display requests previously made."));
2743 add_cmd ("display", class_vars
, enable_display_command
, _("\
2744 Enable some expressions to be displayed when program stops.\n\
2745 Usage: enable display [NUM]...\n\
2746 Arguments are the code numbers of the expressions to resume displaying.\n\
2747 No argument means enable all automatic-display expressions.\n\
2748 Do \"info display\" to see current list of code numbers."), &enablelist
);
2750 add_cmd ("display", class_vars
, disable_display_command
, _("\
2751 Disable some expressions to be displayed when program stops.\n\
2752 Usage: disable display [NUM]...\n\
2753 Arguments are the code numbers of the expressions to stop displaying.\n\
2754 No argument means disable all automatic-display expressions.\n\
2755 Do \"info display\" to see current list of code numbers."), &disablelist
);
2757 add_cmd ("display", class_vars
, undisplay_command
, _("\
2758 Cancel some expressions to be displayed when program stops.\n\
2759 Usage: delete display [NUM]...\n\
2760 Arguments are the code numbers of the expressions to stop displaying.\n\
2761 No argument means cancel all automatic-display expressions.\n\
2762 Do \"info display\" to see current list of code numbers."), &deletelist
);
2764 add_com ("printf", class_vars
, printf_command
, _("\
2765 Formatted printing, like the C \"printf\" function.\n\
2766 Usage: printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
2767 This supports most C printf format specifications, like %s, %d, etc."));
2769 add_com ("output", class_vars
, output_command
, _("\
2770 Like \"print\" but don't put in value history and don't print newline.\n\
2771 Usage: output EXP\n\
2772 This is useful in user-defined commands."));
2774 add_prefix_cmd ("set", class_vars
, set_command
, _("\
2775 Evaluate expression EXP and assign result to variable VAR.\n\
2776 Usage: set VAR = EXP\n\
2777 This uses assignment syntax appropriate for the current language\n\
2778 (VAR = EXP or VAR := EXP for example).\n\
2779 VAR may be a debugger \"convenience\" variable (names starting\n\
2780 with $), a register (a few standard names starting with $), or an actual\n\
2781 variable in the program being debugged. EXP is any valid expression.\n\
2782 Use \"set variable\" for variables with names identical to set subcommands.\n\
2784 With a subcommand, this command modifies parts of the gdb environment.\n\
2785 You can see these environment settings with the \"show\" command."),
2786 &setlist
, "set ", 1, &cmdlist
);
2788 add_com ("assign", class_vars
, set_command
, _("\
2789 Evaluate expression EXP and assign result to variable VAR.\n\
2790 Usage: assign VAR = EXP\n\
2791 This uses assignment syntax appropriate for the current language\n\
2792 (VAR = EXP or VAR := EXP for example).\n\
2793 VAR may be a debugger \"convenience\" variable (names starting\n\
2794 with $), a register (a few standard names starting with $), or an actual\n\
2795 variable in the program being debugged. EXP is any valid expression.\n\
2796 Use \"set variable\" for variables with names identical to set subcommands.\n\
2797 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2798 You can see these environment settings with the \"show\" command."));
2800 /* "call" is the same as "set", but handy for dbx users to call fns. */
2801 c
= add_com ("call", class_vars
, call_command
, _("\
2802 Call a function in the program.\n\
2804 The argument is the function name and arguments, in the notation of the\n\
2805 current working language. The result is printed and saved in the value\n\
2806 history, if it is not void."));
2807 set_cmd_completer_handle_brkchars (c
, print_command_completer
);
2809 add_cmd ("variable", class_vars
, set_command
, _("\
2810 Evaluate expression EXP and assign result to variable VAR.\n\
2811 Usage: set variable VAR = EXP\n\
2812 This uses assignment syntax appropriate for the current language\n\
2813 (VAR = EXP or VAR := EXP for example).\n\
2814 VAR may be a debugger \"convenience\" variable (names starting\n\
2815 with $), a register (a few standard names starting with $), or an actual\n\
2816 variable in the program being debugged. EXP is any valid expression.\n\
2817 This may usually be abbreviated to simply \"set\"."),
2819 add_alias_cmd ("var", "variable", class_vars
, 0, &setlist
);
2821 const auto print_opts
= make_value_print_options_def_group (nullptr);
2823 static const std::string print_help
= gdb::option::build_help (_("\
2824 Print value of expression EXP.\n\
2825 Usage: print [[OPTION]... --] [/FMT] [EXP]\n\
2830 Note: because this command accepts arbitrary expressions, if you\n\
2831 specify any command option, you must use a double dash (\"--\")\n\
2832 to mark the end of option processing. E.g.: \"print -o -- myobj\".\n\
2834 Variables accessible are those of the lexical environment of the selected\n\
2835 stack frame, plus all those whose scope is global or an entire file.\n\
2837 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2838 $$NUM refers to NUM'th value back from the last one.\n\
2839 Names starting with $ refer to registers (with the values they would have\n\
2840 if the program were to return to the stack frame now selected, restoring\n\
2841 all registers saved by frames farther in) or else to debugger\n\
2842 \"convenience\" variables (any such name not a known register).\n\
2843 Use assignment expressions to give values to convenience variables.\n\
2845 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2846 @ is a binary operator for treating consecutive data objects\n\
2847 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2848 element is FOO, whose second element is stored in the space following\n\
2849 where FOO is stored, etc. FOO must be an expression whose value\n\
2850 resides in memory.\n\
2852 EXP may be preceded with /FMT, where FMT is a format letter\n\
2853 but no count or size letter (see \"x\" command)."),
2856 c
= add_com ("print", class_vars
, print_command
, print_help
.c_str ());
2857 set_cmd_completer_handle_brkchars (c
, print_command_completer
);
2858 add_com_alias ("p", "print", class_vars
, 1);
2859 add_com_alias ("inspect", "print", class_vars
, 1);
2861 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class
,
2862 &max_symbolic_offset
, _("\
2863 Set the largest offset that will be printed in <SYMBOL+1234> form."), _("\
2864 Show the largest offset that will be printed in <SYMBOL+1234> form."), _("\
2865 Tell GDB to only display the symbolic form of an address if the\n\
2866 offset between the closest earlier symbol and the address is less than\n\
2867 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
2868 to always print the symbolic form of an address if any symbol precedes\n\
2869 it. Zero is equivalent to \"unlimited\"."),
2871 show_max_symbolic_offset
,
2872 &setprintlist
, &showprintlist
);
2873 add_setshow_boolean_cmd ("symbol-filename", no_class
,
2874 &print_symbol_filename
, _("\
2875 Set printing of source filename and line number with <SYMBOL>."), _("\
2876 Show printing of source filename and line number with <SYMBOL>."), NULL
,
2878 show_print_symbol_filename
,
2879 &setprintlist
, &showprintlist
);
2881 add_com ("eval", no_class
, eval_command
, _("\
2882 Construct a GDB command and then evaluate it.\n\
2883 Usage: eval \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
2884 Convert the arguments to a string as \"printf\" would, but then\n\
2885 treat this string as a command line, and evaluate it."));