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
;
121 /* Chain link to next auto-display item. */
122 struct display
*next
;
124 /* The expression as the user typed it. */
127 /* Expression to be evaluated and displayed. */
130 /* Item number of this auto-display item. */
133 /* Display format specified. */
134 struct format_data format
;
136 /* Program space associated with `block'. */
137 struct program_space
*pspace
;
139 /* Innermost block required by this expression when evaluated. */
140 const struct block
*block
;
142 /* Status of this display (enabled or disabled). */
146 /* Chain of expressions whose values should be displayed
147 automatically each time the program stops. */
149 static struct display
*display_chain
;
151 static int display_number
;
153 /* Walk the following statement or block through all displays.
154 ALL_DISPLAYS_SAFE does so even if the statement deletes the current
157 #define ALL_DISPLAYS(B) \
158 for (B = display_chain; B; B = B->next)
160 #define ALL_DISPLAYS_SAFE(B,TMP) \
161 for (B = display_chain; \
162 B ? (TMP = B->next, 1): 0; \
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
) == TYPE_CODE_REF
315 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
316 || TYPE_CODE (type
) == TYPE_CODE_STRING
317 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
318 || TYPE_CODE (type
) == TYPE_CODE_UNION
319 || TYPE_CODE (type
) == 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
) == 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
) == 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
) == 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
) != TYPE_CODE_FLT
)
437 type
= float_type_from_length (type
);
438 if (TYPE_CODE (type
) != 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
) != 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 TYPE_CODE (value_type (val
)) != 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
= get_objfile_arch (objfile
);
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 (/* last_format == 'i' && */
1685 TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
1686 && VALUE_LVAL (val
) == lval_memory
)
1687 next_address
= value_address (val
);
1689 next_address
= value_as_address (val
);
1691 next_gdbarch
= expr
->gdbarch
;
1695 error_no_arg (_("starting display address"));
1697 do_examine (fmt
, next_gdbarch
, next_address
);
1699 /* If the examine succeeds, we remember its size and format for next
1700 time. Set last_size to 'b' for strings. */
1701 if (fmt
.format
== 's')
1704 last_size
= fmt
.size
;
1705 last_format
= fmt
.format
;
1707 /* Set a couple of internal variables if appropriate. */
1708 if (last_examine_value
!= nullptr)
1710 /* Make last address examined available to the user as $_. Use
1711 the correct pointer type. */
1712 struct type
*pointer_type
1713 = lookup_pointer_type (value_type (last_examine_value
.get ()));
1714 set_internalvar (lookup_internalvar ("_"),
1715 value_from_pointer (pointer_type
,
1716 last_examine_address
));
1718 /* Make contents of last address examined available to the user
1719 as $__. If the last value has not been fetched from memory
1720 then don't fetch it now; instead mark it by voiding the $__
1722 if (value_lazy (last_examine_value
.get ()))
1723 clear_internalvar (lookup_internalvar ("__"));
1725 set_internalvar (lookup_internalvar ("__"), last_examine_value
.get ());
1730 /* Add an expression to the auto-display chain.
1731 Specify the expression. */
1734 display_command (const char *arg
, int from_tty
)
1736 struct format_data fmt
;
1737 struct display
*newobj
;
1738 const char *exp
= arg
;
1749 fmt
= decode_format (&exp
, 0, 0);
1750 if (fmt
.size
&& fmt
.format
== 0)
1752 if (fmt
.format
== 'i' || fmt
.format
== 's')
1763 innermost_block_tracker tracker
;
1764 expression_up expr
= parse_expression (exp
, &tracker
);
1766 newobj
= new display ();
1768 newobj
->exp_string
= xstrdup (exp
);
1769 newobj
->exp
= std::move (expr
);
1770 newobj
->block
= tracker
.block ();
1771 newobj
->pspace
= current_program_space
;
1772 newobj
->number
= ++display_number
;
1773 newobj
->format
= fmt
;
1774 newobj
->enabled_p
= 1;
1775 newobj
->next
= NULL
;
1777 if (display_chain
== NULL
)
1778 display_chain
= newobj
;
1781 struct display
*last
;
1783 for (last
= display_chain
; last
->next
!= NULL
; last
= last
->next
)
1785 last
->next
= newobj
;
1789 do_one_display (newobj
);
1795 free_display (struct display
*d
)
1797 xfree (d
->exp_string
);
1801 /* Clear out the display_chain. Done when new symtabs are loaded,
1802 since this invalidates the types stored in many expressions. */
1805 clear_displays (void)
1809 while ((d
= display_chain
) != NULL
)
1811 display_chain
= d
->next
;
1816 /* Delete the auto-display DISPLAY. */
1819 delete_display (struct display
*display
)
1823 gdb_assert (display
!= NULL
);
1825 if (display_chain
== display
)
1826 display_chain
= display
->next
;
1829 if (d
->next
== display
)
1831 d
->next
= display
->next
;
1835 free_display (display
);
1838 /* Call FUNCTION on each of the displays whose numbers are given in
1839 ARGS. DATA is passed unmodified to FUNCTION. */
1842 map_display_numbers (const char *args
,
1843 void (*function
) (struct display
*,
1850 error_no_arg (_("one or more display numbers"));
1852 number_or_range_parser
parser (args
);
1854 while (!parser
.finished ())
1856 const char *p
= parser
.cur_tok ();
1858 num
= parser
.get_number ();
1860 warning (_("bad display number at or near '%s'"), p
);
1863 struct display
*d
, *tmp
;
1865 ALL_DISPLAYS_SAFE (d
, tmp
)
1866 if (d
->number
== num
)
1869 printf_unfiltered (_("No display number %d.\n"), num
);
1876 /* Callback for map_display_numbers, that deletes a display. */
1879 do_delete_display (struct display
*d
, void *data
)
1884 /* "undisplay" command. */
1887 undisplay_command (const char *args
, int from_tty
)
1891 if (query (_("Delete all auto-display expressions? ")))
1897 map_display_numbers (args
, do_delete_display
, NULL
);
1901 /* Display a single auto-display.
1902 Do nothing if the display cannot be printed in the current context,
1903 or if the display is disabled. */
1906 do_one_display (struct display
*d
)
1908 int within_current_scope
;
1910 if (d
->enabled_p
== 0)
1913 /* The expression carries the architecture that was used at parse time.
1914 This is a problem if the expression depends on architecture features
1915 (e.g. register numbers), and the current architecture is now different.
1916 For example, a display statement like "display/i $pc" is expected to
1917 display the PC register of the current architecture, not the arch at
1918 the time the display command was given. Therefore, we re-parse the
1919 expression if the current architecture has changed. */
1920 if (d
->exp
!= NULL
&& d
->exp
->gdbarch
!= get_current_arch ())
1931 innermost_block_tracker tracker
;
1932 d
->exp
= parse_expression (d
->exp_string
, &tracker
);
1933 d
->block
= tracker
.block ();
1935 catch (const gdb_exception
&ex
)
1937 /* Can't re-parse the expression. Disable this display item. */
1939 warning (_("Unable to display \"%s\": %s"),
1940 d
->exp_string
, ex
.what ());
1947 if (d
->pspace
== current_program_space
)
1948 within_current_scope
= contained_in (get_selected_block (0), d
->block
,
1951 within_current_scope
= 0;
1954 within_current_scope
= 1;
1955 if (!within_current_scope
)
1958 scoped_restore save_display_number
1959 = make_scoped_restore (¤t_display_number
, d
->number
);
1961 annotate_display_begin ();
1962 printf_filtered ("%d", d
->number
);
1963 annotate_display_number_end ();
1964 printf_filtered (": ");
1968 annotate_display_format ();
1970 printf_filtered ("x/");
1971 if (d
->format
.count
!= 1)
1972 printf_filtered ("%d", d
->format
.count
);
1973 printf_filtered ("%c", d
->format
.format
);
1974 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1975 printf_filtered ("%c", d
->format
.size
);
1976 printf_filtered (" ");
1978 annotate_display_expression ();
1980 puts_filtered (d
->exp_string
);
1981 annotate_display_expression_end ();
1983 if (d
->format
.count
!= 1 || d
->format
.format
== 'i')
1984 printf_filtered ("\n");
1986 printf_filtered (" ");
1988 annotate_display_value ();
1995 val
= evaluate_expression (d
->exp
.get ());
1996 addr
= value_as_address (val
);
1997 if (d
->format
.format
== 'i')
1998 addr
= gdbarch_addr_bits_remove (d
->exp
->gdbarch
, addr
);
1999 do_examine (d
->format
, d
->exp
->gdbarch
, addr
);
2001 catch (const gdb_exception_error
&ex
)
2003 fprintf_filtered (gdb_stdout
, _("%p[<error: %s>%p]\n"),
2004 metadata_style
.style ().ptr (), ex
.what (),
2010 struct value_print_options opts
;
2012 annotate_display_format ();
2014 if (d
->format
.format
)
2015 printf_filtered ("/%c ", d
->format
.format
);
2017 annotate_display_expression ();
2019 puts_filtered (d
->exp_string
);
2020 annotate_display_expression_end ();
2022 printf_filtered (" = ");
2024 annotate_display_expression ();
2026 get_formatted_print_options (&opts
, d
->format
.format
);
2027 opts
.raw
= d
->format
.raw
;
2033 val
= evaluate_expression (d
->exp
.get ());
2034 print_formatted (val
, d
->format
.size
, &opts
, gdb_stdout
);
2036 catch (const gdb_exception_error
&ex
)
2038 fprintf_styled (gdb_stdout
, metadata_style
.style (),
2039 _("<error: %s>"), ex
.what ());
2042 printf_filtered ("\n");
2045 annotate_display_end ();
2047 gdb_flush (gdb_stdout
);
2050 /* Display all of the values on the auto-display chain which can be
2051 evaluated in the current scope. */
2058 for (d
= display_chain
; d
; d
= d
->next
)
2062 /* Delete the auto-display which we were in the process of displaying.
2063 This is done when there is an error or a signal. */
2066 disable_display (int num
)
2070 for (d
= display_chain
; d
; d
= d
->next
)
2071 if (d
->number
== num
)
2076 printf_unfiltered (_("No display number %d.\n"), num
);
2080 disable_current_display (void)
2082 if (current_display_number
>= 0)
2084 disable_display (current_display_number
);
2085 fprintf_unfiltered (gdb_stderr
,
2086 _("Disabling display %d to "
2087 "avoid infinite recursion.\n"),
2088 current_display_number
);
2090 current_display_number
= -1;
2094 info_display_command (const char *ignore
, int from_tty
)
2099 printf_unfiltered (_("There are no auto-display expressions now.\n"));
2101 printf_filtered (_("Auto-display expressions now in effect:\n\
2102 Num Enb Expression\n"));
2104 for (d
= display_chain
; d
; d
= d
->next
)
2106 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
2108 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
2110 else if (d
->format
.format
)
2111 printf_filtered ("/%c ", d
->format
.format
);
2112 puts_filtered (d
->exp_string
);
2113 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
, true))
2114 printf_filtered (_(" (cannot be evaluated in the current context)"));
2115 printf_filtered ("\n");
2119 /* Callback fo map_display_numbers, that enables or disables the
2120 passed in display D. */
2123 do_enable_disable_display (struct display
*d
, void *data
)
2125 d
->enabled_p
= *(int *) data
;
2128 /* Implementation of both the "disable display" and "enable display"
2129 commands. ENABLE decides what to do. */
2132 enable_disable_display_command (const char *args
, int from_tty
, int enable
)
2139 d
->enabled_p
= enable
;
2143 map_display_numbers (args
, do_enable_disable_display
, &enable
);
2146 /* The "enable display" command. */
2149 enable_display_command (const char *args
, int from_tty
)
2151 enable_disable_display_command (args
, from_tty
, 1);
2154 /* The "disable display" command. */
2157 disable_display_command (const char *args
, int from_tty
)
2159 enable_disable_display_command (args
, from_tty
, 0);
2162 /* display_chain items point to blocks and expressions. Some expressions in
2163 turn may point to symbols.
2164 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
2165 obstack_free'd when a shared library is unloaded.
2166 Clear pointers that are about to become dangling.
2167 Both .exp and .block fields will be restored next time we need to display
2168 an item by re-parsing .exp_string field in the new execution context. */
2171 clear_dangling_display_expressions (struct objfile
*objfile
)
2174 struct program_space
*pspace
;
2176 /* With no symbol file we cannot have a block or expression from it. */
2177 if (objfile
== NULL
)
2179 pspace
= objfile
->pspace
;
2180 if (objfile
->separate_debug_objfile_backlink
)
2182 objfile
= objfile
->separate_debug_objfile_backlink
;
2183 gdb_assert (objfile
->pspace
== pspace
);
2186 for (d
= display_chain
; d
!= NULL
; d
= d
->next
)
2188 if (d
->pspace
!= pspace
)
2191 if (lookup_objfile_from_block (d
->block
) == objfile
2192 || (d
->exp
!= NULL
&& exp_uses_objfile (d
->exp
.get (), objfile
)))
2201 /* Print the value in stack frame FRAME of a variable specified by a
2202 struct symbol. NAME is the name to print; if NULL then VAR's print
2203 name will be used. STREAM is the ui_file on which to print the
2204 value. INDENT specifies the number of indent levels to print
2205 before printing the variable name.
2207 This function invalidates FRAME. */
2210 print_variable_and_value (const char *name
, struct symbol
*var
,
2211 struct frame_info
*frame
,
2212 struct ui_file
*stream
, int indent
)
2216 name
= var
->print_name ();
2218 fprintf_filtered (stream
, "%s%ps = ", n_spaces (2 * indent
),
2219 styled_string (variable_name_style
.style (), name
));
2224 struct value_print_options opts
;
2226 /* READ_VAR_VALUE needs a block in order to deal with non-local
2227 references (i.e. to handle nested functions). In this context, we
2228 print variables that are local to this frame, so we can avoid passing
2230 val
= read_var_value (var
, NULL
, frame
);
2231 get_user_print_options (&opts
);
2233 common_val_print (val
, stream
, indent
, &opts
, current_language
);
2235 /* common_val_print invalidates FRAME when a pretty printer calls inferior
2239 catch (const gdb_exception_error
&except
)
2241 fprintf_styled (stream
, metadata_style
.style (),
2242 "<error reading variable %s (%s)>", name
,
2246 fprintf_filtered (stream
, "\n");
2249 /* Subroutine of ui_printf to simplify it.
2250 Print VALUE to STREAM using FORMAT.
2251 VALUE is a C-style string either on the target or
2252 in a GDB internal variable. */
2255 printf_c_string (struct ui_file
*stream
, const char *format
,
2256 struct value
*value
)
2258 const gdb_byte
*str
;
2260 if (TYPE_CODE (value_type (value
)) != TYPE_CODE_PTR
2261 && VALUE_LVAL (value
) == lval_internalvar
2262 && c_is_string_type_p (value_type (value
)))
2264 size_t len
= TYPE_LENGTH (value_type (value
));
2266 /* Copy the internal var value to TEM_STR and append a terminating null
2267 character. This protects against corrupted C-style strings that lack
2268 the terminating null char. It also allows Ada-style strings (not
2269 null terminated) to be printed without problems. */
2270 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ 1);
2272 memcpy (tem_str
, value_contents (value
), len
);
2278 CORE_ADDR tem
= value_as_address (value
);;
2283 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2284 fprintf_filtered (stream
, format
, "(null)");
2289 /* This is a %s argument. Find the length of the string. */
2292 for (len
= 0;; len
++)
2297 read_memory (tem
+ len
, &c
, 1);
2302 /* Copy the string contents into a string inside GDB. */
2303 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ 1);
2306 read_memory (tem
, tem_str
, len
);
2312 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2313 fprintf_filtered (stream
, format
, (char *) str
);
2317 /* Subroutine of ui_printf to simplify it.
2318 Print VALUE to STREAM using FORMAT.
2319 VALUE is a wide C-style string on the target or
2320 in a GDB internal variable. */
2323 printf_wide_c_string (struct ui_file
*stream
, const char *format
,
2324 struct value
*value
)
2326 const gdb_byte
*str
;
2328 struct gdbarch
*gdbarch
= get_type_arch (value_type (value
));
2329 struct type
*wctype
= lookup_typename (current_language
,
2330 "wchar_t", NULL
, 0);
2331 int wcwidth
= TYPE_LENGTH (wctype
);
2333 if (VALUE_LVAL (value
) == lval_internalvar
2334 && c_is_string_type_p (value_type (value
)))
2336 str
= value_contents (value
);
2337 len
= TYPE_LENGTH (value_type (value
));
2341 CORE_ADDR tem
= value_as_address (value
);
2346 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2347 fprintf_filtered (stream
, format
, "(null)");
2352 /* This is a %s argument. Find the length of the string. */
2353 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2354 gdb_byte
*buf
= (gdb_byte
*) alloca (wcwidth
);
2356 for (len
= 0;; len
+= wcwidth
)
2359 read_memory (tem
+ len
, buf
, wcwidth
);
2360 if (extract_unsigned_integer (buf
, wcwidth
, byte_order
) == 0)
2364 /* Copy the string contents into a string inside GDB. */
2365 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ wcwidth
);
2368 read_memory (tem
, tem_str
, len
);
2369 memset (&tem_str
[len
], 0, wcwidth
);
2373 auto_obstack output
;
2375 convert_between_encodings (target_wide_charset (gdbarch
),
2378 &output
, translit_char
);
2379 obstack_grow_str0 (&output
, "");
2382 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2383 fprintf_filtered (stream
, format
, obstack_base (&output
));
2387 /* Subroutine of ui_printf to simplify it.
2388 Print VALUE, a floating point value, to STREAM using FORMAT. */
2391 printf_floating (struct ui_file
*stream
, const char *format
,
2392 struct value
*value
, enum argclass argclass
)
2394 /* Parameter data. */
2395 struct type
*param_type
= value_type (value
);
2396 struct gdbarch
*gdbarch
= get_type_arch (param_type
);
2398 /* Determine target type corresponding to the format string. */
2399 struct type
*fmt_type
;
2403 fmt_type
= builtin_type (gdbarch
)->builtin_double
;
2405 case long_double_arg
:
2406 fmt_type
= builtin_type (gdbarch
)->builtin_long_double
;
2408 case dec32float_arg
:
2409 fmt_type
= builtin_type (gdbarch
)->builtin_decfloat
;
2411 case dec64float_arg
:
2412 fmt_type
= builtin_type (gdbarch
)->builtin_decdouble
;
2414 case dec128float_arg
:
2415 fmt_type
= builtin_type (gdbarch
)->builtin_declong
;
2418 gdb_assert_not_reached ("unexpected argument class");
2421 /* To match the traditional GDB behavior, the conversion is
2422 done differently depending on the type of the parameter:
2424 - if the parameter has floating-point type, it's value
2425 is converted to the target type;
2427 - otherwise, if the parameter has a type that is of the
2428 same size as a built-in floating-point type, the value
2429 bytes are interpreted as if they were of that type, and
2430 then converted to the target type (this is not done for
2431 decimal floating-point argument classes);
2433 - otherwise, if the source value has an integer value,
2434 it's value is converted to the target type;
2436 - otherwise, an error is raised.
2438 In either case, the result of the conversion is a byte buffer
2439 formatted in the target format for the target type. */
2441 if (TYPE_CODE (fmt_type
) == TYPE_CODE_FLT
)
2443 param_type
= float_type_from_length (param_type
);
2444 if (param_type
!= value_type (value
))
2445 value
= value_from_contents (param_type
, value_contents (value
));
2448 value
= value_cast (fmt_type
, value
);
2450 /* Convert the value to a string and print it. */
2452 = target_float_to_string (value_contents (value
), fmt_type
, format
);
2453 fputs_filtered (str
.c_str (), stream
);
2456 /* Subroutine of ui_printf to simplify it.
2457 Print VALUE, a target pointer, to STREAM using FORMAT. */
2460 printf_pointer (struct ui_file
*stream
, const char *format
,
2461 struct value
*value
)
2463 /* We avoid the host's %p because pointers are too
2464 likely to be the wrong size. The only interesting
2465 modifier for %p is a width; extract that, and then
2466 handle %p as glibc would: %#x or a literal "(nil)". */
2470 #ifdef PRINTF_HAS_LONG_LONG
2471 long long val
= value_as_long (value
);
2473 long val
= value_as_long (value
);
2476 fmt
= (char *) alloca (strlen (format
) + 5);
2478 /* Copy up to the leading %. */
2483 int is_percent
= (*p
== '%');
2498 /* Copy any width or flags. Only the "-" flag is valid for pointers
2499 -- see the format_pieces constructor. */
2500 while (*p
== '-' || (*p
>= '0' && *p
< '9'))
2503 gdb_assert (*p
== 'p' && *(p
+ 1) == '\0');
2506 #ifdef PRINTF_HAS_LONG_LONG
2513 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2514 fprintf_filtered (stream
, fmt
, val
);
2522 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2523 fprintf_filtered (stream
, fmt
, "(nil)");
2528 /* printf "printf format string" ARG to STREAM. */
2531 ui_printf (const char *arg
, struct ui_file
*stream
)
2533 const char *s
= arg
;
2534 std::vector
<struct value
*> val_args
;
2537 error_no_arg (_("format-control string and values to print"));
2539 s
= skip_spaces (s
);
2541 /* A format string should follow, enveloped in double quotes. */
2543 error (_("Bad format string, missing '\"'."));
2545 format_pieces
fpieces (&s
);
2548 error (_("Bad format string, non-terminated '\"'."));
2550 s
= skip_spaces (s
);
2552 if (*s
!= ',' && *s
!= 0)
2553 error (_("Invalid argument syntax"));
2557 s
= skip_spaces (s
);
2562 const char *current_substring
;
2565 for (auto &&piece
: fpieces
)
2566 if (piece
.argclass
!= literal_piece
)
2569 /* Now, parse all arguments and evaluate them.
2570 Store the VALUEs in VAL_ARGS. */
2577 val_args
.push_back (parse_to_comma_and_eval (&s1
));
2584 if (val_args
.size () != nargs_wanted
)
2585 error (_("Wrong number of arguments for specified format-string"));
2587 /* Now actually print them. */
2589 for (auto &&piece
: fpieces
)
2591 current_substring
= piece
.string
;
2592 switch (piece
.argclass
)
2595 printf_c_string (stream
, current_substring
, val_args
[i
]);
2597 case wide_string_arg
:
2598 printf_wide_c_string (stream
, current_substring
, val_args
[i
]);
2602 struct gdbarch
*gdbarch
2603 = get_type_arch (value_type (val_args
[i
]));
2604 struct type
*wctype
= lookup_typename (current_language
,
2605 "wchar_t", NULL
, 0);
2606 struct type
*valtype
;
2607 const gdb_byte
*bytes
;
2609 valtype
= value_type (val_args
[i
]);
2610 if (TYPE_LENGTH (valtype
) != TYPE_LENGTH (wctype
)
2611 || TYPE_CODE (valtype
) != TYPE_CODE_INT
)
2612 error (_("expected wchar_t argument for %%lc"));
2614 bytes
= value_contents (val_args
[i
]);
2616 auto_obstack output
;
2618 convert_between_encodings (target_wide_charset (gdbarch
),
2620 bytes
, TYPE_LENGTH (valtype
),
2621 TYPE_LENGTH (valtype
),
2622 &output
, translit_char
);
2623 obstack_grow_str0 (&output
, "");
2626 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2627 fprintf_filtered (stream
, current_substring
,
2628 obstack_base (&output
));
2633 #ifdef PRINTF_HAS_LONG_LONG
2635 long long val
= value_as_long (val_args
[i
]);
2638 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2639 fprintf_filtered (stream
, current_substring
, val
);
2644 error (_("long long not supported in printf"));
2648 int val
= value_as_long (val_args
[i
]);
2651 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2652 fprintf_filtered (stream
, current_substring
, val
);
2658 long val
= value_as_long (val_args
[i
]);
2661 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2662 fprintf_filtered (stream
, current_substring
, val
);
2668 size_t val
= value_as_long (val_args
[i
]);
2671 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2672 fprintf_filtered (stream
, current_substring
, val
);
2676 /* Handles floating-point values. */
2678 case long_double_arg
:
2679 case dec32float_arg
:
2680 case dec64float_arg
:
2681 case dec128float_arg
:
2682 printf_floating (stream
, current_substring
, val_args
[i
],
2686 printf_pointer (stream
, current_substring
, val_args
[i
]);
2689 /* Print a portion of the format string that has no
2690 directives. Note that this will not include any
2691 ordinary %-specs, but it might include "%%". That is
2692 why we use printf_filtered and not puts_filtered here.
2693 Also, we pass a dummy argument because some platforms
2694 have modified GCC to include -Wformat-security by
2695 default, which will warn here if there is no
2698 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2699 fprintf_filtered (stream
, current_substring
, 0);
2703 internal_error (__FILE__
, __LINE__
,
2704 _("failed internal consistency check"));
2706 /* Maybe advance to the next argument. */
2707 if (piece
.argclass
!= literal_piece
)
2713 /* Implement the "printf" command. */
2716 printf_command (const char *arg
, int from_tty
)
2718 ui_printf (arg
, gdb_stdout
);
2719 reset_terminal_style (gdb_stdout
);
2721 gdb_stdout
->flush ();
2724 /* Implement the "eval" command. */
2727 eval_command (const char *arg
, int from_tty
)
2731 ui_printf (arg
, &stb
);
2733 std::string expanded
= insert_user_defined_cmd_args (stb
.c_str ());
2735 execute_command (expanded
.c_str (), from_tty
);
2738 void _initialize_printcmd ();
2740 _initialize_printcmd ()
2742 struct cmd_list_element
*c
;
2744 current_display_number
= -1;
2746 gdb::observers::free_objfile
.attach (clear_dangling_display_expressions
);
2748 add_info ("address", info_address_command
,
2749 _("Describe where symbol SYM is stored.\n\
2750 Usage: info address SYM"));
2752 add_info ("symbol", info_symbol_command
, _("\
2753 Describe what symbol is at location ADDR.\n\
2754 Usage: info symbol ADDR\n\
2755 Only for symbols with fixed locations (global or static scope)."));
2757 add_com ("x", class_vars
, x_command
, _("\
2758 Examine memory: x/FMT ADDRESS.\n\
2759 ADDRESS is an expression for the memory address to examine.\n\
2760 FMT is a repeat count followed by a format letter and a size letter.\n\
2761 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2762 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2763 and z(hex, zero padded on the left).\n\
2764 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2765 The specified number of objects of the specified size are printed\n\
2766 according to the format. If a negative number is specified, memory is\n\
2767 examined backward from the address.\n\n\
2768 Defaults for format and size letters are those previously used.\n\
2769 Default count is 1. Default address is following last thing printed\n\
2770 with this command or \"print\"."));
2772 add_info ("display", info_display_command
, _("\
2773 Expressions to display when program stops, with code numbers.\n\
2774 Usage: info display"));
2776 add_cmd ("undisplay", class_vars
, undisplay_command
, _("\
2777 Cancel some expressions to be displayed when program stops.\n\
2778 Usage: undisplay [NUM]...\n\
2779 Arguments are the code numbers of the expressions to stop displaying.\n\
2780 No argument means cancel all automatic-display expressions.\n\
2781 \"delete display\" has the same effect as this command.\n\
2782 Do \"info display\" to see current list of code numbers."),
2785 add_com ("display", class_vars
, display_command
, _("\
2786 Print value of expression EXP each time the program stops.\n\
2787 Usage: display[/FMT] EXP\n\
2788 /FMT may be used before EXP as in the \"print\" command.\n\
2789 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2790 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2791 and examining is done as in the \"x\" command.\n\n\
2792 With no argument, display all currently requested auto-display expressions.\n\
2793 Use \"undisplay\" to cancel display requests previously made."));
2795 add_cmd ("display", class_vars
, enable_display_command
, _("\
2796 Enable some expressions to be displayed when program stops.\n\
2797 Usage: enable display [NUM]...\n\
2798 Arguments are the code numbers of the expressions to resume displaying.\n\
2799 No argument means enable all automatic-display expressions.\n\
2800 Do \"info display\" to see current list of code numbers."), &enablelist
);
2802 add_cmd ("display", class_vars
, disable_display_command
, _("\
2803 Disable some expressions to be displayed when program stops.\n\
2804 Usage: disable display [NUM]...\n\
2805 Arguments are the code numbers of the expressions to stop displaying.\n\
2806 No argument means disable all automatic-display expressions.\n\
2807 Do \"info display\" to see current list of code numbers."), &disablelist
);
2809 add_cmd ("display", class_vars
, undisplay_command
, _("\
2810 Cancel some expressions to be displayed when program stops.\n\
2811 Usage: delete display [NUM]...\n\
2812 Arguments are the code numbers of the expressions to stop displaying.\n\
2813 No argument means cancel all automatic-display expressions.\n\
2814 Do \"info display\" to see current list of code numbers."), &deletelist
);
2816 add_com ("printf", class_vars
, printf_command
, _("\
2817 Formatted printing, like the C \"printf\" function.\n\
2818 Usage: printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
2819 This supports most C printf format specifications, like %s, %d, etc."));
2821 add_com ("output", class_vars
, output_command
, _("\
2822 Like \"print\" but don't put in value history and don't print newline.\n\
2823 Usage: output EXP\n\
2824 This is useful in user-defined commands."));
2826 add_prefix_cmd ("set", class_vars
, set_command
, _("\
2827 Evaluate expression EXP and assign result to variable VAR.\n\
2828 Usage: set VAR = EXP\n\
2829 This uses assignment syntax appropriate for the current language\n\
2830 (VAR = EXP or VAR := EXP for example).\n\
2831 VAR may be a debugger \"convenience\" variable (names starting\n\
2832 with $), a register (a few standard names starting with $), or an actual\n\
2833 variable in the program being debugged. EXP is any valid expression.\n\
2834 Use \"set variable\" for variables with names identical to set subcommands.\n\
2836 With a subcommand, this command modifies parts of the gdb environment.\n\
2837 You can see these environment settings with the \"show\" command."),
2838 &setlist
, "set ", 1, &cmdlist
);
2840 add_com ("assign", class_vars
, set_command
, _("\
2841 Evaluate expression EXP and assign result to variable VAR.\n\
2842 Usage: assign VAR = EXP\n\
2843 This uses assignment syntax appropriate for the current language\n\
2844 (VAR = EXP or VAR := EXP for example).\n\
2845 VAR may be a debugger \"convenience\" variable (names starting\n\
2846 with $), a register (a few standard names starting with $), or an actual\n\
2847 variable in the program being debugged. EXP is any valid expression.\n\
2848 Use \"set variable\" for variables with names identical to set subcommands.\n\
2849 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2850 You can see these environment settings with the \"show\" command."));
2852 /* "call" is the same as "set", but handy for dbx users to call fns. */
2853 c
= add_com ("call", class_vars
, call_command
, _("\
2854 Call a function in the program.\n\
2856 The argument is the function name and arguments, in the notation of the\n\
2857 current working language. The result is printed and saved in the value\n\
2858 history, if it is not void."));
2859 set_cmd_completer_handle_brkchars (c
, print_command_completer
);
2861 add_cmd ("variable", class_vars
, set_command
, _("\
2862 Evaluate expression EXP and assign result to variable VAR.\n\
2863 Usage: set variable VAR = EXP\n\
2864 This uses assignment syntax appropriate for the current language\n\
2865 (VAR = EXP or VAR := EXP for example).\n\
2866 VAR may be a debugger \"convenience\" variable (names starting\n\
2867 with $), a register (a few standard names starting with $), or an actual\n\
2868 variable in the program being debugged. EXP is any valid expression.\n\
2869 This may usually be abbreviated to simply \"set\"."),
2871 add_alias_cmd ("var", "variable", class_vars
, 0, &setlist
);
2873 const auto print_opts
= make_value_print_options_def_group (nullptr);
2875 static const std::string print_help
= gdb::option::build_help (_("\
2876 Print value of expression EXP.\n\
2877 Usage: print [[OPTION]... --] [/FMT] [EXP]\n\
2882 Note: because this command accepts arbitrary expressions, if you\n\
2883 specify any command option, you must use a double dash (\"--\")\n\
2884 to mark the end of option processing. E.g.: \"print -o -- myobj\".\n\
2886 Variables accessible are those of the lexical environment of the selected\n\
2887 stack frame, plus all those whose scope is global or an entire file.\n\
2889 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2890 $$NUM refers to NUM'th value back from the last one.\n\
2891 Names starting with $ refer to registers (with the values they would have\n\
2892 if the program were to return to the stack frame now selected, restoring\n\
2893 all registers saved by frames farther in) or else to debugger\n\
2894 \"convenience\" variables (any such name not a known register).\n\
2895 Use assignment expressions to give values to convenience variables.\n\
2897 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2898 @ is a binary operator for treating consecutive data objects\n\
2899 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2900 element is FOO, whose second element is stored in the space following\n\
2901 where FOO is stored, etc. FOO must be an expression whose value\n\
2902 resides in memory.\n\
2904 EXP may be preceded with /FMT, where FMT is a format letter\n\
2905 but no count or size letter (see \"x\" command)."),
2908 c
= add_com ("print", class_vars
, print_command
, print_help
.c_str ());
2909 set_cmd_completer_handle_brkchars (c
, print_command_completer
);
2910 add_com_alias ("p", "print", class_vars
, 1);
2911 add_com_alias ("inspect", "print", class_vars
, 1);
2913 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class
,
2914 &max_symbolic_offset
, _("\
2915 Set the largest offset that will be printed in <SYMBOL+1234> form."), _("\
2916 Show the largest offset that will be printed in <SYMBOL+1234> form."), _("\
2917 Tell GDB to only display the symbolic form of an address if the\n\
2918 offset between the closest earlier symbol and the address is less than\n\
2919 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
2920 to always print the symbolic form of an address if any symbol precedes\n\
2921 it. Zero is equivalent to \"unlimited\"."),
2923 show_max_symbolic_offset
,
2924 &setprintlist
, &showprintlist
);
2925 add_setshow_boolean_cmd ("symbol-filename", no_class
,
2926 &print_symbol_filename
, _("\
2927 Set printing of source filename and line number with <SYMBOL>."), _("\
2928 Show printing of source filename and line number with <SYMBOL>."), NULL
,
2930 show_print_symbol_filename
,
2931 &setprintlist
, &showprintlist
);
2933 add_com ("eval", no_class
, eval_command
, _("\
2934 Construct a GDB command and then evaluate it.\n\
2935 Usage: eval \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
2936 Convert the arguments to a string as \"printf\" would, but then\n\
2937 treat this string as a command line, and evaluate it."));