1 /* Print values for GNU debugger GDB.
3 Copyright (C) 1986-2019 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 int print_symbol_filename
= 0;
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 val_print_scalar_formatted (type
,
325 value_embedded_offset (val
),
327 options
, size
, stream
);
330 /* Return builtin floating point type of same length as TYPE.
331 If no such type is found, return TYPE itself. */
333 float_type_from_length (struct type
*type
)
335 struct gdbarch
*gdbarch
= get_type_arch (type
);
336 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
338 if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_float
))
339 type
= builtin
->builtin_float
;
340 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_double
))
341 type
= builtin
->builtin_double
;
342 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_long_double
))
343 type
= builtin
->builtin_long_double
;
348 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
349 according to OPTIONS and SIZE on STREAM. Formats s and i are not
350 supported at this level. */
353 print_scalar_formatted (const gdb_byte
*valaddr
, struct type
*type
,
354 const struct value_print_options
*options
,
355 int size
, struct ui_file
*stream
)
357 struct gdbarch
*gdbarch
= get_type_arch (type
);
358 unsigned int len
= TYPE_LENGTH (type
);
359 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
361 /* String printing should go through val_print_scalar_formatted. */
362 gdb_assert (options
->format
!= 's');
364 /* If the value is a pointer, and pointers and addresses are not the
365 same, then at this point, the value's length (in target bytes) is
366 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
367 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
368 len
= gdbarch_addr_bit (gdbarch
) / TARGET_CHAR_BIT
;
370 /* If we are printing it as unsigned, truncate it in case it is actually
371 a negative signed value (e.g. "print/u (short)-1" should print 65535
372 (if shorts are 16 bits) instead of 4294967295). */
373 if (options
->format
!= 'c'
374 && (options
->format
!= 'd' || TYPE_UNSIGNED (type
)))
376 if (len
< TYPE_LENGTH (type
) && byte_order
== BFD_ENDIAN_BIG
)
377 valaddr
+= TYPE_LENGTH (type
) - len
;
380 if (size
!= 0 && (options
->format
== 'x' || options
->format
== 't'))
382 /* Truncate to fit. */
399 error (_("Undefined output size \"%c\"."), size
);
401 if (newlen
< len
&& byte_order
== BFD_ENDIAN_BIG
)
402 valaddr
+= len
- newlen
;
406 /* Historically gdb has printed floats by first casting them to a
407 long, and then printing the long. PR cli/16242 suggests changing
408 this to using C-style hex float format. */
409 gdb::byte_vector converted_float_bytes
;
410 if (TYPE_CODE (type
) == TYPE_CODE_FLT
411 && (options
->format
== 'o'
412 || options
->format
== 'x'
413 || options
->format
== 't'
414 || options
->format
== 'z'
415 || options
->format
== 'd'
416 || options
->format
== 'u'))
418 LONGEST val_long
= unpack_long (type
, valaddr
);
419 converted_float_bytes
.resize (TYPE_LENGTH (type
));
420 store_signed_integer (converted_float_bytes
.data (), TYPE_LENGTH (type
),
421 byte_order
, val_long
);
422 valaddr
= converted_float_bytes
.data ();
425 /* Printing a non-float type as 'f' will interpret the data as if it were
426 of a floating-point type of the same length, if that exists. Otherwise,
427 the data is printed as integer. */
428 char format
= options
->format
;
429 if (format
== 'f' && TYPE_CODE (type
) != TYPE_CODE_FLT
)
431 type
= float_type_from_length (type
);
432 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
439 print_octal_chars (stream
, valaddr
, len
, byte_order
);
442 print_decimal_chars (stream
, valaddr
, len
, true, byte_order
);
445 print_decimal_chars (stream
, valaddr
, len
, false, byte_order
);
448 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
450 print_decimal_chars (stream
, valaddr
, len
, !TYPE_UNSIGNED (type
),
456 print_floating (valaddr
, type
, stream
);
460 print_binary_chars (stream
, valaddr
, len
, byte_order
, size
> 0);
463 print_hex_chars (stream
, valaddr
, len
, byte_order
, size
> 0);
466 print_hex_chars (stream
, valaddr
, len
, byte_order
, true);
470 struct value_print_options opts
= *options
;
472 LONGEST val_long
= unpack_long (type
, valaddr
);
475 if (TYPE_UNSIGNED (type
))
476 type
= builtin_type (gdbarch
)->builtin_true_unsigned_char
;
478 type
= builtin_type (gdbarch
)->builtin_true_char
;
480 value_print (value_from_longest (type
, val_long
), stream
, &opts
);
486 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
488 print_address (gdbarch
, addr
, stream
);
493 error (_("Undefined output format \"%c\"."), format
);
497 /* Specify default address for `x' command.
498 The `info lines' command uses this. */
501 set_next_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
503 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
505 next_gdbarch
= gdbarch
;
508 /* Make address available to the user as $_. */
509 set_internalvar (lookup_internalvar ("_"),
510 value_from_pointer (ptr_type
, addr
));
513 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
514 after LEADIN. Print nothing if no symbolic name is found nearby.
515 Optionally also print source file and line number, if available.
516 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
517 or to interpret it as a possible C++ name and convert it back to source
518 form. However note that DO_DEMANGLE can be overridden by the specific
519 settings of the demangle and asm_demangle variables. Returns
520 non-zero if anything was printed; zero otherwise. */
523 print_address_symbolic (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
524 struct ui_file
*stream
,
525 int do_demangle
, const char *leadin
)
527 std::string name
, filename
;
532 if (build_address_symbolic (gdbarch
, addr
, do_demangle
, &name
, &offset
,
533 &filename
, &line
, &unmapped
))
536 fputs_filtered (leadin
, stream
);
538 fputs_filtered ("<*", stream
);
540 fputs_filtered ("<", stream
);
541 fputs_styled (name
.c_str (), function_name_style
.style (), stream
);
543 fprintf_filtered (stream
, "+%u", (unsigned int) offset
);
545 /* Append source filename and line number if desired. Give specific
546 line # of this addr, if we have it; else line # of the nearest symbol. */
547 if (print_symbol_filename
&& !filename
.empty ())
549 fputs_filtered (line
== -1 ? " in " : " at ", stream
);
550 fputs_styled (filename
.c_str (), file_name_style
.style (), stream
);
552 fprintf_filtered (stream
, ":%d", line
);
555 fputs_filtered ("*>", stream
);
557 fputs_filtered (">", stream
);
562 /* See valprint.h. */
565 build_address_symbolic (struct gdbarch
*gdbarch
,
566 CORE_ADDR addr
, /* IN */
567 int do_demangle
, /* IN */
568 std::string
*name
, /* OUT */
569 int *offset
, /* OUT */
570 std::string
*filename
, /* OUT */
572 int *unmapped
) /* OUT */
574 struct bound_minimal_symbol msymbol
;
575 struct symbol
*symbol
;
576 CORE_ADDR name_location
= 0;
577 struct obj_section
*section
= NULL
;
578 const char *name_temp
= "";
580 /* Let's say it is mapped (not unmapped). */
583 /* Determine if the address is in an overlay, and whether it is
585 if (overlay_debugging
)
587 section
= find_pc_overlay (addr
);
588 if (pc_in_unmapped_range (addr
, section
))
591 addr
= overlay_mapped_address (addr
, section
);
595 /* First try to find the address in the symbol table, then
596 in the minsyms. Take the closest one. */
598 /* This is defective in the sense that it only finds text symbols. So
599 really this is kind of pointless--we should make sure that the
600 minimal symbols have everything we need (by changing that we could
601 save some memory, but for many debug format--ELF/DWARF or
602 anything/stabs--it would be inconvenient to eliminate those minimal
604 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
605 symbol
= find_pc_sect_function (addr
, section
);
609 /* If this is a function (i.e. a code address), strip out any
610 non-address bits. For instance, display a pointer to the
611 first instruction of a Thumb function as <function>; the
612 second instruction will be <function+2>, even though the
613 pointer is <function+3>. This matches the ISA behavior. */
614 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
616 name_location
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (symbol
));
617 if (do_demangle
|| asm_demangle
)
618 name_temp
= SYMBOL_PRINT_NAME (symbol
);
620 name_temp
= SYMBOL_LINKAGE_NAME (symbol
);
623 if (msymbol
.minsym
!= NULL
624 && MSYMBOL_HAS_SIZE (msymbol
.minsym
)
625 && MSYMBOL_SIZE (msymbol
.minsym
) == 0
626 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text
627 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text_gnu_ifunc
628 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_file_text
)
629 msymbol
.minsym
= NULL
;
631 if (msymbol
.minsym
!= NULL
)
633 if (BMSYMBOL_VALUE_ADDRESS (msymbol
) > name_location
|| symbol
== NULL
)
635 /* If this is a function (i.e. a code address), strip out any
636 non-address bits. For instance, display a pointer to the
637 first instruction of a Thumb function as <function>; the
638 second instruction will be <function+2>, even though the
639 pointer is <function+3>. This matches the ISA behavior. */
640 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_text
641 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_text_gnu_ifunc
642 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_text
643 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
644 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
646 /* The msymbol is closer to the address than the symbol;
647 use the msymbol instead. */
649 name_location
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
650 if (do_demangle
|| asm_demangle
)
651 name_temp
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
653 name_temp
= MSYMBOL_LINKAGE_NAME (msymbol
.minsym
);
656 if (symbol
== NULL
&& msymbol
.minsym
== NULL
)
659 /* If the nearest symbol is too far away, don't print anything symbolic. */
661 /* For when CORE_ADDR is larger than unsigned int, we do math in
662 CORE_ADDR. But when we detect unsigned wraparound in the
663 CORE_ADDR math, we ignore this test and print the offset,
664 because addr+max_symbolic_offset has wrapped through the end
665 of the address space back to the beginning, giving bogus comparison. */
666 if (addr
> name_location
+ max_symbolic_offset
667 && name_location
+ max_symbolic_offset
> name_location
)
670 *offset
= addr
- name_location
;
674 if (print_symbol_filename
)
676 struct symtab_and_line sal
;
678 sal
= find_pc_sect_line (addr
, section
, 0);
682 *filename
= symtab_to_filename_for_display (sal
.symtab
);
690 /* Print address ADDR symbolically on STREAM.
691 First print it as a number. Then perhaps print
692 <SYMBOL + OFFSET> after the number. */
695 print_address (struct gdbarch
*gdbarch
,
696 CORE_ADDR addr
, struct ui_file
*stream
)
698 fputs_styled (paddress (gdbarch
, addr
), address_style
.style (), stream
);
699 print_address_symbolic (gdbarch
, addr
, stream
, asm_demangle
, " ");
702 /* Return a prefix for instruction address:
703 "=> " for current instruction, else " ". */
706 pc_prefix (CORE_ADDR addr
)
708 if (has_stack_frames ())
710 struct frame_info
*frame
;
713 frame
= get_selected_frame (NULL
);
714 if (get_frame_pc_if_available (frame
, &pc
) && pc
== addr
)
720 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
721 controls whether to print the symbolic name "raw" or demangled.
722 Return non-zero if anything was printed; zero otherwise. */
725 print_address_demangle (const struct value_print_options
*opts
,
726 struct gdbarch
*gdbarch
, CORE_ADDR addr
,
727 struct ui_file
*stream
, int do_demangle
)
729 if (opts
->addressprint
)
731 fputs_styled (paddress (gdbarch
, addr
), address_style
.style (), stream
);
732 print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, " ");
736 return print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, "");
742 /* Find the address of the instruction that is INST_COUNT instructions before
743 the instruction at ADDR.
744 Since some architectures have variable-length instructions, we can't just
745 simply subtract INST_COUNT * INSN_LEN from ADDR. Instead, we use line
746 number information to locate the nearest known instruction boundary,
747 and disassemble forward from there. If we go out of the symbol range
748 during disassembling, we return the lowest address we've got so far and
749 set the number of instructions read to INST_READ. */
752 find_instruction_backward (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
753 int inst_count
, int *inst_read
)
755 /* The vector PCS is used to store instruction addresses within
757 CORE_ADDR loop_start
, loop_end
, p
;
758 std::vector
<CORE_ADDR
> pcs
;
759 struct symtab_and_line sal
;
762 loop_start
= loop_end
= addr
;
764 /* In each iteration of the outer loop, we get a pc range that ends before
765 LOOP_START, then we count and store every instruction address of the range
766 iterated in the loop.
767 If the number of instructions counted reaches INST_COUNT, return the
768 stored address that is located INST_COUNT instructions back from ADDR.
769 If INST_COUNT is not reached, we subtract the number of counted
770 instructions from INST_COUNT, and go to the next iteration. */
774 sal
= find_pc_sect_line (loop_start
, NULL
, 1);
777 /* We reach here when line info is not available. In this case,
778 we print a message and just exit the loop. The return value
779 is calculated after the loop. */
780 printf_filtered (_("No line number information available "
783 print_address (gdbarch
, loop_start
- 1, gdb_stdout
);
784 printf_filtered ("\n");
788 loop_end
= loop_start
;
791 /* This loop pushes instruction addresses in the range from
792 LOOP_START to LOOP_END. */
793 for (p
= loop_start
; p
< loop_end
;)
796 p
+= gdb_insn_length (gdbarch
, p
);
799 inst_count
-= pcs
.size ();
800 *inst_read
+= pcs
.size ();
802 while (inst_count
> 0);
804 /* After the loop, the vector PCS has instruction addresses of the last
805 source line we processed, and INST_COUNT has a negative value.
806 We return the address at the index of -INST_COUNT in the vector for
808 Let's assume the following instruction addresses and run 'x/-4i 0x400e'.
818 find_instruction_backward is called with INST_COUNT = 4 and expected to
819 return 0x4001. When we reach here, INST_COUNT is set to -1 because
820 it was subtracted by 2 (from Line Y) and 3 (from Line X). The value
821 4001 is located at the index 1 of the last iterated line (= Line X),
822 which is simply calculated by -INST_COUNT.
823 The case when the length of PCS is 0 means that we reached an area for
824 which line info is not available. In such case, we return LOOP_START,
825 which was the lowest instruction address that had line info. */
826 p
= pcs
.size () > 0 ? pcs
[-inst_count
] : loop_start
;
828 /* INST_READ includes all instruction addresses in a pc range. Need to
829 exclude the beginning part up to the address we're returning. That
830 is, exclude {0x4000} in the example above. */
832 *inst_read
+= inst_count
;
837 /* Backward read LEN bytes of target memory from address MEMADDR + LEN,
838 placing the results in GDB's memory from MYADDR + LEN. Returns
839 a count of the bytes actually read. */
842 read_memory_backward (struct gdbarch
*gdbarch
,
843 CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
846 int nread
; /* Number of bytes actually read. */
848 /* First try a complete read. */
849 errcode
= target_read_memory (memaddr
, myaddr
, len
);
857 /* Loop, reading one byte at a time until we get as much as we can. */
860 for (nread
= 0; nread
< len
; ++nread
)
862 errcode
= target_read_memory (--memaddr
, --myaddr
, 1);
865 /* The read was unsuccessful, so exit the loop. */
866 printf_filtered (_("Cannot access memory at address %s\n"),
867 paddress (gdbarch
, memaddr
));
875 /* Returns true if X (which is LEN bytes wide) is the number zero. */
878 integer_is_zero (const gdb_byte
*x
, int len
)
882 while (i
< len
&& x
[i
] == 0)
887 /* Find the start address of a string in which ADDR is included.
888 Basically we search for '\0' and return the next address,
889 but if OPTIONS->PRINT_MAX is smaller than the length of a string,
890 we stop searching and return the address to print characters as many as
891 PRINT_MAX from the string. */
894 find_string_backward (struct gdbarch
*gdbarch
,
895 CORE_ADDR addr
, int count
, int char_size
,
896 const struct value_print_options
*options
,
897 int *strings_counted
)
899 const int chunk_size
= 0x20;
902 int chars_to_read
= chunk_size
;
903 int chars_counted
= 0;
904 int count_original
= count
;
905 CORE_ADDR string_start_addr
= addr
;
907 gdb_assert (char_size
== 1 || char_size
== 2 || char_size
== 4);
908 gdb::byte_vector
buffer (chars_to_read
* char_size
);
909 while (count
> 0 && read_error
== 0)
913 addr
-= chars_to_read
* char_size
;
914 chars_read
= read_memory_backward (gdbarch
, addr
, buffer
.data (),
915 chars_to_read
* char_size
);
916 chars_read
/= char_size
;
917 read_error
= (chars_read
== chars_to_read
) ? 0 : 1;
918 /* Searching for '\0' from the end of buffer in backward direction. */
919 for (i
= 0; i
< chars_read
&& count
> 0 ; ++i
, ++chars_counted
)
921 int offset
= (chars_to_read
- i
- 1) * char_size
;
923 if (integer_is_zero (&buffer
[offset
], char_size
)
924 || chars_counted
== options
->print_max
)
926 /* Found '\0' or reached print_max. As OFFSET is the offset to
927 '\0', we add CHAR_SIZE to return the start address of
930 string_start_addr
= addr
+ offset
+ char_size
;
936 /* Update STRINGS_COUNTED with the actual number of loaded strings. */
937 *strings_counted
= count_original
- count
;
941 /* In error case, STRING_START_ADDR is pointing to the string that
942 was last successfully loaded. Rewind the partially loaded string. */
943 string_start_addr
-= chars_counted
* char_size
;
946 return string_start_addr
;
949 /* Examine data at address ADDR in format FMT.
950 Fetch it from memory and print on gdb_stdout. */
953 do_examine (struct format_data fmt
, struct gdbarch
*gdbarch
, CORE_ADDR addr
)
958 struct type
*val_type
= NULL
;
961 struct value_print_options opts
;
962 int need_to_update_next_address
= 0;
963 CORE_ADDR addr_rewound
= 0;
968 next_gdbarch
= gdbarch
;
971 /* Instruction format implies fetch single bytes
972 regardless of the specified size.
973 The case of strings is handled in decode_format, only explicit
974 size operator are not changed to 'b'. */
980 /* Pick the appropriate size for an address. */
981 if (gdbarch_ptr_bit (next_gdbarch
) == 64)
983 else if (gdbarch_ptr_bit (next_gdbarch
) == 32)
985 else if (gdbarch_ptr_bit (next_gdbarch
) == 16)
988 /* Bad value for gdbarch_ptr_bit. */
989 internal_error (__FILE__
, __LINE__
,
990 _("failed internal consistency check"));
994 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
995 else if (size
== 'h')
996 val_type
= builtin_type (next_gdbarch
)->builtin_int16
;
997 else if (size
== 'w')
998 val_type
= builtin_type (next_gdbarch
)->builtin_int32
;
999 else if (size
== 'g')
1000 val_type
= builtin_type (next_gdbarch
)->builtin_int64
;
1004 struct type
*char_type
= NULL
;
1006 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
1007 if type is not found. */
1009 char_type
= builtin_type (next_gdbarch
)->builtin_char16
;
1010 else if (size
== 'w')
1011 char_type
= builtin_type (next_gdbarch
)->builtin_char32
;
1013 val_type
= char_type
;
1016 if (size
!= '\0' && size
!= 'b')
1017 warning (_("Unable to display strings with "
1018 "size '%c', using 'b' instead."), size
);
1020 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1029 if (format
== 's' || format
== 'i')
1032 get_formatted_print_options (&opts
, format
);
1036 /* This is the negative repeat count case.
1037 We rewind the address based on the given repeat count and format,
1038 then examine memory from there in forward direction. */
1043 next_address
= find_instruction_backward (gdbarch
, addr
, count
,
1046 else if (format
== 's')
1048 next_address
= find_string_backward (gdbarch
, addr
, count
,
1049 TYPE_LENGTH (val_type
),
1054 next_address
= addr
- count
* TYPE_LENGTH (val_type
);
1057 /* The following call to print_formatted updates next_address in every
1058 iteration. In backward case, we store the start address here
1059 and update next_address with it before exiting the function. */
1060 addr_rewound
= (format
== 's'
1061 ? next_address
- TYPE_LENGTH (val_type
)
1063 need_to_update_next_address
= 1;
1066 /* Print as many objects as specified in COUNT, at most maxelts per line,
1067 with the address of the next one at the start of each line. */
1073 fputs_filtered (pc_prefix (next_address
), gdb_stdout
);
1074 print_address (next_gdbarch
, next_address
, gdb_stdout
);
1075 printf_filtered (":");
1080 printf_filtered ("\t");
1081 /* Note that print_formatted sets next_address for the next
1083 last_examine_address
= next_address
;
1085 /* The value to be displayed is not fetched greedily.
1086 Instead, to avoid the possibility of a fetched value not
1087 being used, its retrieval is delayed until the print code
1088 uses it. When examining an instruction stream, the
1089 disassembler will perform its own memory fetch using just
1090 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
1091 the disassembler be modified so that LAST_EXAMINE_VALUE
1092 is left with the byte sequence from the last complete
1093 instruction fetched from memory? */
1095 = release_value (value_at_lazy (val_type
, next_address
));
1097 print_formatted (last_examine_value
.get (), size
, &opts
, gdb_stdout
);
1099 /* Display any branch delay slots following the final insn. */
1100 if (format
== 'i' && count
== 1)
1101 count
+= branch_delay_insns
;
1103 printf_filtered ("\n");
1106 if (need_to_update_next_address
)
1107 next_address
= addr_rewound
;
1111 validate_format (struct format_data fmt
, const char *cmdname
)
1114 error (_("Size letters are meaningless in \"%s\" command."), cmdname
);
1116 error (_("Item count other than 1 is meaningless in \"%s\" command."),
1118 if (fmt
.format
== 'i')
1119 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
1120 fmt
.format
, cmdname
);
1123 /* Parse print command format string into *OPTS and update *EXPP.
1124 CMDNAME should name the current command. */
1127 print_command_parse_format (const char **expp
, const char *cmdname
,
1128 value_print_options
*opts
)
1130 const char *exp
= *expp
;
1132 if (exp
&& *exp
== '/')
1137 fmt
= decode_format (&exp
, last_format
, 0);
1138 validate_format (fmt
, cmdname
);
1139 last_format
= fmt
.format
;
1141 opts
->format
= fmt
.format
;
1142 opts
->raw
= fmt
.raw
;
1153 /* See valprint.h. */
1156 print_value (value
*val
, const value_print_options
&opts
)
1158 int histindex
= record_latest_value (val
);
1160 annotate_value_history_begin (histindex
, value_type (val
));
1162 printf_filtered ("$%d = ", histindex
);
1164 annotate_value_history_value ();
1166 print_formatted (val
, 0, &opts
, gdb_stdout
);
1167 printf_filtered ("\n");
1169 annotate_value_history_end ();
1172 /* Implementation of the "print" and "call" commands. */
1175 print_command_1 (const char *args
, int voidprint
)
1178 value_print_options print_opts
;
1180 get_user_print_options (&print_opts
);
1181 /* Override global settings with explicit options, if any. */
1182 auto group
= make_value_print_options_def_group (&print_opts
);
1183 gdb::option::process_options
1184 (&args
, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER
, group
);
1186 print_command_parse_format (&args
, "print", &print_opts
);
1188 const char *exp
= args
;
1190 if (exp
!= nullptr && *exp
)
1192 expression_up expr
= parse_expression (exp
);
1193 val
= evaluate_expression (expr
.get ());
1196 val
= access_value_history (0);
1198 if (voidprint
|| (val
&& value_type (val
) &&
1199 TYPE_CODE (value_type (val
)) != TYPE_CODE_VOID
))
1200 print_value (val
, print_opts
);
1203 /* See valprint.h. */
1206 print_command_completer (struct cmd_list_element
*ignore
,
1207 completion_tracker
&tracker
,
1208 const char *text
, const char * /*word*/)
1210 const auto group
= make_value_print_options_def_group (nullptr);
1211 if (gdb::option::complete_options
1212 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER
, group
))
1215 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
1216 expression_completer (ignore
, tracker
, text
, word
);
1220 print_command (const char *exp
, int from_tty
)
1222 print_command_1 (exp
, 1);
1225 /* Same as print, except it doesn't print void results. */
1227 call_command (const char *exp
, int from_tty
)
1229 print_command_1 (exp
, 0);
1232 /* Implementation of the "output" command. */
1235 output_command (const char *exp
, int from_tty
)
1239 struct format_data fmt
;
1240 struct value_print_options opts
;
1245 if (exp
&& *exp
== '/')
1248 fmt
= decode_format (&exp
, 0, 0);
1249 validate_format (fmt
, "output");
1250 format
= fmt
.format
;
1253 expression_up expr
= parse_expression (exp
);
1255 val
= evaluate_expression (expr
.get ());
1257 annotate_value_begin (value_type (val
));
1259 get_formatted_print_options (&opts
, format
);
1261 print_formatted (val
, fmt
.size
, &opts
, gdb_stdout
);
1263 annotate_value_end ();
1266 gdb_flush (gdb_stdout
);
1270 set_command (const char *exp
, int from_tty
)
1272 expression_up expr
= parse_expression (exp
);
1274 if (expr
->nelts
>= 1)
1275 switch (expr
->elts
[0].opcode
)
1277 case UNOP_PREINCREMENT
:
1278 case UNOP_POSTINCREMENT
:
1279 case UNOP_PREDECREMENT
:
1280 case UNOP_POSTDECREMENT
:
1282 case BINOP_ASSIGN_MODIFY
:
1287 (_("Expression is not an assignment (and might have no effect)"));
1290 evaluate_expression (expr
.get ());
1294 info_symbol_command (const char *arg
, int from_tty
)
1296 struct minimal_symbol
*msymbol
;
1297 struct obj_section
*osect
;
1298 CORE_ADDR addr
, sect_addr
;
1300 unsigned int offset
;
1303 error_no_arg (_("address"));
1305 addr
= parse_and_eval_address (arg
);
1306 for (objfile
*objfile
: current_program_space
->objfiles ())
1307 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
1309 /* Only process each object file once, even if there's a separate
1311 if (objfile
->separate_debug_objfile_backlink
)
1314 sect_addr
= overlay_mapped_address (addr
, osect
);
1316 if (obj_section_addr (osect
) <= sect_addr
1317 && sect_addr
< obj_section_endaddr (osect
)
1319 = lookup_minimal_symbol_by_pc_section (sect_addr
,
1322 const char *obj_name
, *mapped
, *sec_name
, *msym_name
;
1323 const char *loc_string
;
1326 offset
= sect_addr
- MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
);
1327 mapped
= section_is_mapped (osect
) ? _("mapped") : _("unmapped");
1328 sec_name
= osect
->the_bfd_section
->name
;
1329 msym_name
= MSYMBOL_PRINT_NAME (msymbol
);
1331 /* Don't print the offset if it is zero.
1332 We assume there's no need to handle i18n of "sym + offset". */
1333 std::string string_holder
;
1336 string_holder
= string_printf ("%s + %u", msym_name
, offset
);
1337 loc_string
= string_holder
.c_str ();
1340 loc_string
= msym_name
;
1342 gdb_assert (osect
->objfile
&& objfile_name (osect
->objfile
));
1343 obj_name
= objfile_name (osect
->objfile
);
1345 if (MULTI_OBJFILE_P ())
1346 if (pc_in_unmapped_range (addr
, osect
))
1347 if (section_is_overlay (osect
))
1348 printf_filtered (_("%s in load address range of "
1349 "%s overlay section %s of %s\n"),
1350 loc_string
, mapped
, sec_name
, obj_name
);
1352 printf_filtered (_("%s in load address range of "
1353 "section %s of %s\n"),
1354 loc_string
, sec_name
, obj_name
);
1356 if (section_is_overlay (osect
))
1357 printf_filtered (_("%s in %s overlay section %s of %s\n"),
1358 loc_string
, mapped
, sec_name
, obj_name
);
1360 printf_filtered (_("%s in section %s of %s\n"),
1361 loc_string
, sec_name
, obj_name
);
1363 if (pc_in_unmapped_range (addr
, osect
))
1364 if (section_is_overlay (osect
))
1365 printf_filtered (_("%s in load address range of %s overlay "
1367 loc_string
, mapped
, sec_name
);
1370 (_("%s in load address range of section %s\n"),
1371 loc_string
, sec_name
);
1373 if (section_is_overlay (osect
))
1374 printf_filtered (_("%s in %s overlay section %s\n"),
1375 loc_string
, mapped
, sec_name
);
1377 printf_filtered (_("%s in section %s\n"),
1378 loc_string
, sec_name
);
1382 printf_filtered (_("No symbol matches %s.\n"), arg
);
1386 info_address_command (const char *exp
, int from_tty
)
1388 struct gdbarch
*gdbarch
;
1391 struct bound_minimal_symbol msymbol
;
1393 struct obj_section
*section
;
1394 CORE_ADDR load_addr
, context_pc
= 0;
1395 struct field_of_this_result is_a_field_of_this
;
1398 error (_("Argument required."));
1400 sym
= lookup_symbol (exp
, get_selected_block (&context_pc
), VAR_DOMAIN
,
1401 &is_a_field_of_this
).symbol
;
1404 if (is_a_field_of_this
.type
!= NULL
)
1406 printf_filtered ("Symbol \"");
1407 fprintf_symbol_filtered (gdb_stdout
, exp
,
1408 current_language
->la_language
, DMGL_ANSI
);
1409 printf_filtered ("\" is a field of the local class variable ");
1410 if (current_language
->la_language
== language_objc
)
1411 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1413 printf_filtered ("`this'\n");
1417 msymbol
= lookup_bound_minimal_symbol (exp
);
1419 if (msymbol
.minsym
!= NULL
)
1421 struct objfile
*objfile
= msymbol
.objfile
;
1423 gdbarch
= get_objfile_arch (objfile
);
1424 load_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
1426 printf_filtered ("Symbol \"");
1427 fprintf_symbol_filtered (gdb_stdout
, exp
,
1428 current_language
->la_language
, DMGL_ANSI
);
1429 printf_filtered ("\" is at ");
1430 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1432 printf_filtered (" in a file compiled without debugging");
1433 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
1434 if (section_is_overlay (section
))
1436 load_addr
= overlay_unmapped_address (load_addr
, section
);
1437 printf_filtered (",\n -- loaded at ");
1438 fputs_styled (paddress (gdbarch
, load_addr
),
1439 address_style
.style (),
1441 printf_filtered (" in overlay section %s",
1442 section
->the_bfd_section
->name
);
1444 printf_filtered (".\n");
1447 error (_("No symbol \"%s\" in current context."), exp
);
1451 printf_filtered ("Symbol \"");
1452 fprintf_symbol_filtered (gdb_stdout
, SYMBOL_PRINT_NAME (sym
),
1453 current_language
->la_language
, DMGL_ANSI
);
1454 printf_filtered ("\" is ");
1455 val
= SYMBOL_VALUE (sym
);
1456 if (SYMBOL_OBJFILE_OWNED (sym
))
1457 section
= SYMBOL_OBJ_SECTION (symbol_objfile (sym
), sym
);
1460 gdbarch
= symbol_arch (sym
);
1462 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
1464 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, context_pc
,
1466 printf_filtered (".\n");
1470 switch (SYMBOL_CLASS (sym
))
1473 case LOC_CONST_BYTES
:
1474 printf_filtered ("constant");
1478 printf_filtered ("a label at address ");
1479 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1480 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1482 if (section_is_overlay (section
))
1484 load_addr
= overlay_unmapped_address (load_addr
, section
);
1485 printf_filtered (",\n -- loaded at ");
1486 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1488 printf_filtered (" in overlay section %s",
1489 section
->the_bfd_section
->name
);
1494 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
1497 /* GDBARCH is the architecture associated with the objfile the symbol
1498 is defined in; the target architecture may be different, and may
1499 provide additional registers. However, we do not know the target
1500 architecture at this point. We assume the objfile architecture
1501 will contain all the standard registers that occur in debug info
1503 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1505 if (SYMBOL_IS_ARGUMENT (sym
))
1506 printf_filtered (_("an argument in register %s"),
1507 gdbarch_register_name (gdbarch
, regno
));
1509 printf_filtered (_("a variable in register %s"),
1510 gdbarch_register_name (gdbarch
, regno
));
1514 printf_filtered (_("static storage at address "));
1515 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1516 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1518 if (section_is_overlay (section
))
1520 load_addr
= overlay_unmapped_address (load_addr
, section
);
1521 printf_filtered (_(",\n -- loaded at "));
1522 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1524 printf_filtered (_(" in overlay section %s"),
1525 section
->the_bfd_section
->name
);
1529 case LOC_REGPARM_ADDR
:
1530 /* Note comment at LOC_REGISTER. */
1531 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1532 printf_filtered (_("address of an argument in register %s"),
1533 gdbarch_register_name (gdbarch
, regno
));
1537 printf_filtered (_("an argument at offset %ld"), val
);
1541 printf_filtered (_("a local variable at frame offset %ld"), val
);
1545 printf_filtered (_("a reference argument at offset %ld"), val
);
1549 printf_filtered (_("a typedef"));
1553 printf_filtered (_("a function at address "));
1554 load_addr
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
1555 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1557 if (section_is_overlay (section
))
1559 load_addr
= overlay_unmapped_address (load_addr
, section
);
1560 printf_filtered (_(",\n -- loaded at "));
1561 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1563 printf_filtered (_(" in overlay section %s"),
1564 section
->the_bfd_section
->name
);
1568 case LOC_UNRESOLVED
:
1570 struct bound_minimal_symbol msym
;
1572 msym
= lookup_bound_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
));
1573 if (msym
.minsym
== NULL
)
1574 printf_filtered ("unresolved");
1577 section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
1580 && (section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
1582 load_addr
= MSYMBOL_VALUE_RAW_ADDRESS (msym
.minsym
);
1583 printf_filtered (_("a thread-local variable at offset %s "
1584 "in the thread-local storage for `%s'"),
1585 paddress (gdbarch
, load_addr
),
1586 objfile_name (section
->objfile
));
1590 load_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
1591 printf_filtered (_("static storage at address "));
1592 fputs_styled (paddress (gdbarch
, load_addr
),
1593 address_style
.style (), gdb_stdout
);
1594 if (section_is_overlay (section
))
1596 load_addr
= overlay_unmapped_address (load_addr
, section
);
1597 printf_filtered (_(",\n -- loaded at "));
1598 fputs_styled (paddress (gdbarch
, load_addr
),
1599 address_style
.style (),
1601 printf_filtered (_(" in overlay section %s"),
1602 section
->the_bfd_section
->name
);
1609 case LOC_OPTIMIZED_OUT
:
1610 printf_filtered (_("optimized out"));
1614 printf_filtered (_("of unknown (botched) type"));
1617 printf_filtered (".\n");
1622 x_command (const char *exp
, int from_tty
)
1624 struct format_data fmt
;
1627 fmt
.format
= last_format
? last_format
: 'x';
1628 fmt
.size
= last_size
;
1632 /* If there is no expression and no format, use the most recent
1634 if (exp
== nullptr && last_count
> 0)
1635 fmt
.count
= last_count
;
1637 if (exp
&& *exp
== '/')
1639 const char *tmp
= exp
+ 1;
1641 fmt
= decode_format (&tmp
, last_format
, last_size
);
1645 last_count
= fmt
.count
;
1647 /* If we have an expression, evaluate it and use it as the address. */
1649 if (exp
!= 0 && *exp
!= 0)
1651 expression_up expr
= parse_expression (exp
);
1652 /* Cause expression not to be there any more if this command is
1653 repeated with Newline. But don't clobber a user-defined
1654 command's definition. */
1656 set_repeat_arguments ("");
1657 val
= evaluate_expression (expr
.get ());
1658 if (TYPE_IS_REFERENCE (value_type (val
)))
1659 val
= coerce_ref (val
);
1660 /* In rvalue contexts, such as this, functions are coerced into
1661 pointers to functions. This makes "x/i main" work. */
1662 if (/* last_format == 'i' && */
1663 TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
1664 && VALUE_LVAL (val
) == lval_memory
)
1665 next_address
= value_address (val
);
1667 next_address
= value_as_address (val
);
1669 next_gdbarch
= expr
->gdbarch
;
1673 error_no_arg (_("starting display address"));
1675 do_examine (fmt
, next_gdbarch
, next_address
);
1677 /* If the examine succeeds, we remember its size and format for next
1678 time. Set last_size to 'b' for strings. */
1679 if (fmt
.format
== 's')
1682 last_size
= fmt
.size
;
1683 last_format
= fmt
.format
;
1685 /* Set a couple of internal variables if appropriate. */
1686 if (last_examine_value
!= nullptr)
1688 /* Make last address examined available to the user as $_. Use
1689 the correct pointer type. */
1690 struct type
*pointer_type
1691 = lookup_pointer_type (value_type (last_examine_value
.get ()));
1692 set_internalvar (lookup_internalvar ("_"),
1693 value_from_pointer (pointer_type
,
1694 last_examine_address
));
1696 /* Make contents of last address examined available to the user
1697 as $__. If the last value has not been fetched from memory
1698 then don't fetch it now; instead mark it by voiding the $__
1700 if (value_lazy (last_examine_value
.get ()))
1701 clear_internalvar (lookup_internalvar ("__"));
1703 set_internalvar (lookup_internalvar ("__"), last_examine_value
.get ());
1708 /* Add an expression to the auto-display chain.
1709 Specify the expression. */
1712 display_command (const char *arg
, int from_tty
)
1714 struct format_data fmt
;
1715 struct display
*newobj
;
1716 const char *exp
= arg
;
1727 fmt
= decode_format (&exp
, 0, 0);
1728 if (fmt
.size
&& fmt
.format
== 0)
1730 if (fmt
.format
== 'i' || fmt
.format
== 's')
1741 innermost_block_tracker tracker
;
1742 expression_up expr
= parse_expression (exp
, &tracker
);
1744 newobj
= new display ();
1746 newobj
->exp_string
= xstrdup (exp
);
1747 newobj
->exp
= std::move (expr
);
1748 newobj
->block
= tracker
.block ();
1749 newobj
->pspace
= current_program_space
;
1750 newobj
->number
= ++display_number
;
1751 newobj
->format
= fmt
;
1752 newobj
->enabled_p
= 1;
1753 newobj
->next
= NULL
;
1755 if (display_chain
== NULL
)
1756 display_chain
= newobj
;
1759 struct display
*last
;
1761 for (last
= display_chain
; last
->next
!= NULL
; last
= last
->next
)
1763 last
->next
= newobj
;
1767 do_one_display (newobj
);
1773 free_display (struct display
*d
)
1775 xfree (d
->exp_string
);
1779 /* Clear out the display_chain. Done when new symtabs are loaded,
1780 since this invalidates the types stored in many expressions. */
1783 clear_displays (void)
1787 while ((d
= display_chain
) != NULL
)
1789 display_chain
= d
->next
;
1794 /* Delete the auto-display DISPLAY. */
1797 delete_display (struct display
*display
)
1801 gdb_assert (display
!= NULL
);
1803 if (display_chain
== display
)
1804 display_chain
= display
->next
;
1807 if (d
->next
== display
)
1809 d
->next
= display
->next
;
1813 free_display (display
);
1816 /* Call FUNCTION on each of the displays whose numbers are given in
1817 ARGS. DATA is passed unmodified to FUNCTION. */
1820 map_display_numbers (const char *args
,
1821 void (*function
) (struct display
*,
1828 error_no_arg (_("one or more display numbers"));
1830 number_or_range_parser
parser (args
);
1832 while (!parser
.finished ())
1834 const char *p
= parser
.cur_tok ();
1836 num
= parser
.get_number ();
1838 warning (_("bad display number at or near '%s'"), p
);
1841 struct display
*d
, *tmp
;
1843 ALL_DISPLAYS_SAFE (d
, tmp
)
1844 if (d
->number
== num
)
1847 printf_unfiltered (_("No display number %d.\n"), num
);
1854 /* Callback for map_display_numbers, that deletes a display. */
1857 do_delete_display (struct display
*d
, void *data
)
1862 /* "undisplay" command. */
1865 undisplay_command (const char *args
, int from_tty
)
1869 if (query (_("Delete all auto-display expressions? ")))
1875 map_display_numbers (args
, do_delete_display
, NULL
);
1879 /* Display a single auto-display.
1880 Do nothing if the display cannot be printed in the current context,
1881 or if the display is disabled. */
1884 do_one_display (struct display
*d
)
1886 int within_current_scope
;
1888 if (d
->enabled_p
== 0)
1891 /* The expression carries the architecture that was used at parse time.
1892 This is a problem if the expression depends on architecture features
1893 (e.g. register numbers), and the current architecture is now different.
1894 For example, a display statement like "display/i $pc" is expected to
1895 display the PC register of the current architecture, not the arch at
1896 the time the display command was given. Therefore, we re-parse the
1897 expression if the current architecture has changed. */
1898 if (d
->exp
!= NULL
&& d
->exp
->gdbarch
!= get_current_arch ())
1909 innermost_block_tracker tracker
;
1910 d
->exp
= parse_expression (d
->exp_string
, &tracker
);
1911 d
->block
= tracker
.block ();
1913 catch (const gdb_exception
&ex
)
1915 /* Can't re-parse the expression. Disable this display item. */
1917 warning (_("Unable to display \"%s\": %s"),
1918 d
->exp_string
, ex
.what ());
1925 if (d
->pspace
== current_program_space
)
1926 within_current_scope
= contained_in (get_selected_block (0), d
->block
);
1928 within_current_scope
= 0;
1931 within_current_scope
= 1;
1932 if (!within_current_scope
)
1935 scoped_restore save_display_number
1936 = make_scoped_restore (¤t_display_number
, d
->number
);
1938 annotate_display_begin ();
1939 printf_filtered ("%d", d
->number
);
1940 annotate_display_number_end ();
1941 printf_filtered (": ");
1945 annotate_display_format ();
1947 printf_filtered ("x/");
1948 if (d
->format
.count
!= 1)
1949 printf_filtered ("%d", d
->format
.count
);
1950 printf_filtered ("%c", d
->format
.format
);
1951 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1952 printf_filtered ("%c", d
->format
.size
);
1953 printf_filtered (" ");
1955 annotate_display_expression ();
1957 puts_filtered (d
->exp_string
);
1958 annotate_display_expression_end ();
1960 if (d
->format
.count
!= 1 || d
->format
.format
== 'i')
1961 printf_filtered ("\n");
1963 printf_filtered (" ");
1965 annotate_display_value ();
1972 val
= evaluate_expression (d
->exp
.get ());
1973 addr
= value_as_address (val
);
1974 if (d
->format
.format
== 'i')
1975 addr
= gdbarch_addr_bits_remove (d
->exp
->gdbarch
, addr
);
1976 do_examine (d
->format
, d
->exp
->gdbarch
, addr
);
1978 catch (const gdb_exception_error
&ex
)
1980 fprintf_filtered (gdb_stdout
, _("<error: %s>\n"),
1986 struct value_print_options opts
;
1988 annotate_display_format ();
1990 if (d
->format
.format
)
1991 printf_filtered ("/%c ", d
->format
.format
);
1993 annotate_display_expression ();
1995 puts_filtered (d
->exp_string
);
1996 annotate_display_expression_end ();
1998 printf_filtered (" = ");
2000 annotate_display_expression ();
2002 get_formatted_print_options (&opts
, d
->format
.format
);
2003 opts
.raw
= d
->format
.raw
;
2009 val
= evaluate_expression (d
->exp
.get ());
2010 print_formatted (val
, d
->format
.size
, &opts
, gdb_stdout
);
2012 catch (const gdb_exception_error
&ex
)
2014 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.what ());
2017 printf_filtered ("\n");
2020 annotate_display_end ();
2022 gdb_flush (gdb_stdout
);
2025 /* Display all of the values on the auto-display chain which can be
2026 evaluated in the current scope. */
2033 for (d
= display_chain
; d
; d
= d
->next
)
2037 /* Delete the auto-display which we were in the process of displaying.
2038 This is done when there is an error or a signal. */
2041 disable_display (int num
)
2045 for (d
= display_chain
; d
; d
= d
->next
)
2046 if (d
->number
== num
)
2051 printf_unfiltered (_("No display number %d.\n"), num
);
2055 disable_current_display (void)
2057 if (current_display_number
>= 0)
2059 disable_display (current_display_number
);
2060 fprintf_unfiltered (gdb_stderr
,
2061 _("Disabling display %d to "
2062 "avoid infinite recursion.\n"),
2063 current_display_number
);
2065 current_display_number
= -1;
2069 info_display_command (const char *ignore
, int from_tty
)
2074 printf_unfiltered (_("There are no auto-display expressions now.\n"));
2076 printf_filtered (_("Auto-display expressions now in effect:\n\
2077 Num Enb Expression\n"));
2079 for (d
= display_chain
; d
; d
= d
->next
)
2081 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
2083 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
2085 else if (d
->format
.format
)
2086 printf_filtered ("/%c ", d
->format
.format
);
2087 puts_filtered (d
->exp_string
);
2088 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
))
2089 printf_filtered (_(" (cannot be evaluated in the current context)"));
2090 printf_filtered ("\n");
2094 /* Callback fo map_display_numbers, that enables or disables the
2095 passed in display D. */
2098 do_enable_disable_display (struct display
*d
, void *data
)
2100 d
->enabled_p
= *(int *) data
;
2103 /* Implamentation of both the "disable display" and "enable display"
2104 commands. ENABLE decides what to do. */
2107 enable_disable_display_command (const char *args
, int from_tty
, int enable
)
2114 d
->enabled_p
= enable
;
2118 map_display_numbers (args
, do_enable_disable_display
, &enable
);
2121 /* The "enable display" command. */
2124 enable_display_command (const char *args
, int from_tty
)
2126 enable_disable_display_command (args
, from_tty
, 1);
2129 /* The "disable display" command. */
2132 disable_display_command (const char *args
, int from_tty
)
2134 enable_disable_display_command (args
, from_tty
, 0);
2137 /* display_chain items point to blocks and expressions. Some expressions in
2138 turn may point to symbols.
2139 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
2140 obstack_free'd when a shared library is unloaded.
2141 Clear pointers that are about to become dangling.
2142 Both .exp and .block fields will be restored next time we need to display
2143 an item by re-parsing .exp_string field in the new execution context. */
2146 clear_dangling_display_expressions (struct objfile
*objfile
)
2149 struct program_space
*pspace
;
2151 /* With no symbol file we cannot have a block or expression from it. */
2152 if (objfile
== NULL
)
2154 pspace
= objfile
->pspace
;
2155 if (objfile
->separate_debug_objfile_backlink
)
2157 objfile
= objfile
->separate_debug_objfile_backlink
;
2158 gdb_assert (objfile
->pspace
== pspace
);
2161 for (d
= display_chain
; d
!= NULL
; d
= d
->next
)
2163 if (d
->pspace
!= pspace
)
2166 if (lookup_objfile_from_block (d
->block
) == objfile
2167 || (d
->exp
!= NULL
&& exp_uses_objfile (d
->exp
.get (), objfile
)))
2176 /* Print the value in stack frame FRAME of a variable specified by a
2177 struct symbol. NAME is the name to print; if NULL then VAR's print
2178 name will be used. STREAM is the ui_file on which to print the
2179 value. INDENT specifies the number of indent levels to print
2180 before printing the variable name.
2182 This function invalidates FRAME. */
2185 print_variable_and_value (const char *name
, struct symbol
*var
,
2186 struct frame_info
*frame
,
2187 struct ui_file
*stream
, int indent
)
2191 name
= SYMBOL_PRINT_NAME (var
);
2193 fputs_filtered (n_spaces (2 * indent
), stream
);
2194 fputs_styled (name
, variable_name_style
.style (), stream
);
2195 fputs_filtered (" = ", stream
);
2200 struct value_print_options opts
;
2202 /* READ_VAR_VALUE needs a block in order to deal with non-local
2203 references (i.e. to handle nested functions). In this context, we
2204 print variables that are local to this frame, so we can avoid passing
2206 val
= read_var_value (var
, NULL
, frame
);
2207 get_user_print_options (&opts
);
2209 common_val_print (val
, stream
, indent
, &opts
, current_language
);
2211 /* common_val_print invalidates FRAME when a pretty printer calls inferior
2215 catch (const gdb_exception_error
&except
)
2217 fprintf_filtered (stream
, "<error reading variable %s (%s)>", name
,
2221 fprintf_filtered (stream
, "\n");
2224 /* Subroutine of ui_printf to simplify it.
2225 Print VALUE to STREAM using FORMAT.
2226 VALUE is a C-style string either on the target or
2227 in a GDB internal variable. */
2230 printf_c_string (struct ui_file
*stream
, const char *format
,
2231 struct value
*value
)
2233 const gdb_byte
*str
;
2235 if (VALUE_LVAL (value
) == lval_internalvar
2236 && c_is_string_type_p (value_type (value
)))
2238 size_t len
= TYPE_LENGTH (value_type (value
));
2240 /* Copy the internal var value to TEM_STR and append a terminating null
2241 character. This protects against corrupted C-style strings that lack
2242 the terminating null char. It also allows Ada-style strings (not
2243 null terminated) to be printed without problems. */
2244 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ 1);
2246 memcpy (tem_str
, value_contents (value
), len
);
2252 CORE_ADDR tem
= value_as_address (value
);;
2257 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2258 fprintf_filtered (stream
, format
, "(null)");
2263 /* This is a %s argument. Find the length of the string. */
2266 for (len
= 0;; len
++)
2271 read_memory (tem
+ len
, &c
, 1);
2276 /* Copy the string contents into a string inside GDB. */
2277 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ 1);
2280 read_memory (tem
, tem_str
, len
);
2286 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2287 fprintf_filtered (stream
, format
, (char *) str
);
2291 /* Subroutine of ui_printf to simplify it.
2292 Print VALUE to STREAM using FORMAT.
2293 VALUE is a wide C-style string on the target or
2294 in a GDB internal variable. */
2297 printf_wide_c_string (struct ui_file
*stream
, const char *format
,
2298 struct value
*value
)
2300 const gdb_byte
*str
;
2302 struct gdbarch
*gdbarch
= get_type_arch (value_type (value
));
2303 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2304 "wchar_t", NULL
, 0);
2305 int wcwidth
= TYPE_LENGTH (wctype
);
2307 if (VALUE_LVAL (value
) == lval_internalvar
2308 && c_is_string_type_p (value_type (value
)))
2310 str
= value_contents (value
);
2311 len
= TYPE_LENGTH (value_type (value
));
2315 CORE_ADDR tem
= value_as_address (value
);
2320 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2321 fprintf_filtered (stream
, format
, "(null)");
2326 /* This is a %s argument. Find the length of the string. */
2327 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2328 gdb_byte
*buf
= (gdb_byte
*) alloca (wcwidth
);
2330 for (len
= 0;; len
+= wcwidth
)
2333 read_memory (tem
+ len
, buf
, wcwidth
);
2334 if (extract_unsigned_integer (buf
, wcwidth
, byte_order
) == 0)
2338 /* Copy the string contents into a string inside GDB. */
2339 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ wcwidth
);
2342 read_memory (tem
, tem_str
, len
);
2343 memset (&tem_str
[len
], 0, wcwidth
);
2347 auto_obstack output
;
2349 convert_between_encodings (target_wide_charset (gdbarch
),
2352 &output
, translit_char
);
2353 obstack_grow_str0 (&output
, "");
2356 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2357 fprintf_filtered (stream
, format
, obstack_base (&output
));
2361 /* Subroutine of ui_printf to simplify it.
2362 Print VALUE, a floating point value, to STREAM using FORMAT. */
2365 printf_floating (struct ui_file
*stream
, const char *format
,
2366 struct value
*value
, enum argclass argclass
)
2368 /* Parameter data. */
2369 struct type
*param_type
= value_type (value
);
2370 struct gdbarch
*gdbarch
= get_type_arch (param_type
);
2372 /* Determine target type corresponding to the format string. */
2373 struct type
*fmt_type
;
2377 fmt_type
= builtin_type (gdbarch
)->builtin_double
;
2379 case long_double_arg
:
2380 fmt_type
= builtin_type (gdbarch
)->builtin_long_double
;
2382 case dec32float_arg
:
2383 fmt_type
= builtin_type (gdbarch
)->builtin_decfloat
;
2385 case dec64float_arg
:
2386 fmt_type
= builtin_type (gdbarch
)->builtin_decdouble
;
2388 case dec128float_arg
:
2389 fmt_type
= builtin_type (gdbarch
)->builtin_declong
;
2392 gdb_assert_not_reached ("unexpected argument class");
2395 /* To match the traditional GDB behavior, the conversion is
2396 done differently depending on the type of the parameter:
2398 - if the parameter has floating-point type, it's value
2399 is converted to the target type;
2401 - otherwise, if the parameter has a type that is of the
2402 same size as a built-in floating-point type, the value
2403 bytes are interpreted as if they were of that type, and
2404 then converted to the target type (this is not done for
2405 decimal floating-point argument classes);
2407 - otherwise, if the source value has an integer value,
2408 it's value is converted to the target type;
2410 - otherwise, an error is raised.
2412 In either case, the result of the conversion is a byte buffer
2413 formatted in the target format for the target type. */
2415 if (TYPE_CODE (fmt_type
) == TYPE_CODE_FLT
)
2417 param_type
= float_type_from_length (param_type
);
2418 if (param_type
!= value_type (value
))
2419 value
= value_from_contents (param_type
, value_contents (value
));
2422 value
= value_cast (fmt_type
, value
);
2424 /* Convert the value to a string and print it. */
2426 = target_float_to_string (value_contents (value
), fmt_type
, format
);
2427 fputs_filtered (str
.c_str (), stream
);
2430 /* Subroutine of ui_printf to simplify it.
2431 Print VALUE, a target pointer, to STREAM using FORMAT. */
2434 printf_pointer (struct ui_file
*stream
, const char *format
,
2435 struct value
*value
)
2437 /* We avoid the host's %p because pointers are too
2438 likely to be the wrong size. The only interesting
2439 modifier for %p is a width; extract that, and then
2440 handle %p as glibc would: %#x or a literal "(nil)". */
2444 #ifdef PRINTF_HAS_LONG_LONG
2445 long long val
= value_as_long (value
);
2447 long val
= value_as_long (value
);
2450 fmt
= (char *) alloca (strlen (format
) + 5);
2452 /* Copy up to the leading %. */
2457 int is_percent
= (*p
== '%');
2472 /* Copy any width or flags. Only the "-" flag is valid for pointers
2473 -- see the format_pieces constructor. */
2474 while (*p
== '-' || (*p
>= '0' && *p
< '9'))
2477 gdb_assert (*p
== 'p' && *(p
+ 1) == '\0');
2480 #ifdef PRINTF_HAS_LONG_LONG
2487 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2488 fprintf_filtered (stream
, fmt
, val
);
2496 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2497 fprintf_filtered (stream
, fmt
, "(nil)");
2502 /* printf "printf format string" ARG to STREAM. */
2505 ui_printf (const char *arg
, struct ui_file
*stream
)
2507 const char *s
= arg
;
2508 std::vector
<struct value
*> val_args
;
2511 error_no_arg (_("format-control string and values to print"));
2513 s
= skip_spaces (s
);
2515 /* A format string should follow, enveloped in double quotes. */
2517 error (_("Bad format string, missing '\"'."));
2519 format_pieces
fpieces (&s
);
2522 error (_("Bad format string, non-terminated '\"'."));
2524 s
= skip_spaces (s
);
2526 if (*s
!= ',' && *s
!= 0)
2527 error (_("Invalid argument syntax"));
2531 s
= skip_spaces (s
);
2536 const char *current_substring
;
2539 for (auto &&piece
: fpieces
)
2540 if (piece
.argclass
!= literal_piece
)
2543 /* Now, parse all arguments and evaluate them.
2544 Store the VALUEs in VAL_ARGS. */
2551 val_args
.push_back (parse_to_comma_and_eval (&s1
));
2558 if (val_args
.size () != nargs_wanted
)
2559 error (_("Wrong number of arguments for specified format-string"));
2561 /* Now actually print them. */
2563 for (auto &&piece
: fpieces
)
2565 current_substring
= piece
.string
;
2566 switch (piece
.argclass
)
2569 printf_c_string (stream
, current_substring
, val_args
[i
]);
2571 case wide_string_arg
:
2572 printf_wide_c_string (stream
, current_substring
, val_args
[i
]);
2576 struct gdbarch
*gdbarch
2577 = get_type_arch (value_type (val_args
[i
]));
2578 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2579 "wchar_t", NULL
, 0);
2580 struct type
*valtype
;
2581 const gdb_byte
*bytes
;
2583 valtype
= value_type (val_args
[i
]);
2584 if (TYPE_LENGTH (valtype
) != TYPE_LENGTH (wctype
)
2585 || TYPE_CODE (valtype
) != TYPE_CODE_INT
)
2586 error (_("expected wchar_t argument for %%lc"));
2588 bytes
= value_contents (val_args
[i
]);
2590 auto_obstack output
;
2592 convert_between_encodings (target_wide_charset (gdbarch
),
2594 bytes
, TYPE_LENGTH (valtype
),
2595 TYPE_LENGTH (valtype
),
2596 &output
, translit_char
);
2597 obstack_grow_str0 (&output
, "");
2600 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2601 fprintf_filtered (stream
, current_substring
,
2602 obstack_base (&output
));
2607 #ifdef PRINTF_HAS_LONG_LONG
2609 long long val
= value_as_long (val_args
[i
]);
2612 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2613 fprintf_filtered (stream
, current_substring
, val
);
2618 error (_("long long not supported in printf"));
2622 int val
= value_as_long (val_args
[i
]);
2625 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2626 fprintf_filtered (stream
, current_substring
, val
);
2632 long val
= value_as_long (val_args
[i
]);
2635 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2636 fprintf_filtered (stream
, current_substring
, val
);
2640 /* Handles floating-point values. */
2642 case long_double_arg
:
2643 case dec32float_arg
:
2644 case dec64float_arg
:
2645 case dec128float_arg
:
2646 printf_floating (stream
, current_substring
, val_args
[i
],
2650 printf_pointer (stream
, current_substring
, val_args
[i
]);
2653 /* Print a portion of the format string that has no
2654 directives. Note that this will not include any
2655 ordinary %-specs, but it might include "%%". That is
2656 why we use printf_filtered and not puts_filtered here.
2657 Also, we pass a dummy argument because some platforms
2658 have modified GCC to include -Wformat-security by
2659 default, which will warn here if there is no
2662 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2663 fprintf_filtered (stream
, current_substring
, 0);
2667 internal_error (__FILE__
, __LINE__
,
2668 _("failed internal consistency check"));
2670 /* Maybe advance to the next argument. */
2671 if (piece
.argclass
!= literal_piece
)
2677 /* Implement the "printf" command. */
2680 printf_command (const char *arg
, int from_tty
)
2682 ui_printf (arg
, gdb_stdout
);
2683 reset_terminal_style (gdb_stdout
);
2685 gdb_flush (gdb_stdout
);
2688 /* Implement the "eval" command. */
2691 eval_command (const char *arg
, int from_tty
)
2695 ui_printf (arg
, &stb
);
2697 std::string expanded
= insert_user_defined_cmd_args (stb
.c_str ());
2699 execute_command (expanded
.c_str (), from_tty
);
2703 _initialize_printcmd (void)
2705 struct cmd_list_element
*c
;
2707 current_display_number
= -1;
2709 gdb::observers::free_objfile
.attach (clear_dangling_display_expressions
);
2711 add_info ("address", info_address_command
,
2712 _("Describe where symbol SYM is stored.\n\
2713 Usage: info address SYM"));
2715 add_info ("symbol", info_symbol_command
, _("\
2716 Describe what symbol is at location ADDR.\n\
2717 Usage: info symbol ADDR\n\
2718 Only for symbols with fixed locations (global or static scope)."));
2720 add_com ("x", class_vars
, x_command
, _("\
2721 Examine memory: x/FMT ADDRESS.\n\
2722 ADDRESS is an expression for the memory address to examine.\n\
2723 FMT is a repeat count followed by a format letter and a size letter.\n\
2724 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2725 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2726 and z(hex, zero padded on the left).\n\
2727 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2728 The specified number of objects of the specified size are printed\n\
2729 according to the format. If a negative number is specified, memory is\n\
2730 examined backward from the address.\n\n\
2731 Defaults for format and size letters are those previously used.\n\
2732 Default count is 1. Default address is following last thing printed\n\
2733 with this command or \"print\"."));
2735 add_info ("display", info_display_command
, _("\
2736 Expressions to display when program stops, with code numbers.\n\
2737 Usage: info display"));
2739 add_cmd ("undisplay", class_vars
, undisplay_command
, _("\
2740 Cancel some expressions to be displayed when program stops.\n\
2741 Usage: undisplay [NUM]...\n\
2742 Arguments are the code numbers of the expressions to stop displaying.\n\
2743 No argument means cancel all automatic-display expressions.\n\
2744 \"delete display\" has the same effect as this command.\n\
2745 Do \"info display\" to see current list of code numbers."),
2748 add_com ("display", class_vars
, display_command
, _("\
2749 Print value of expression EXP each time the program stops.\n\
2750 Usage: display[/FMT] EXP\n\
2751 /FMT may be used before EXP as in the \"print\" command.\n\
2752 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2753 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2754 and examining is done as in the \"x\" command.\n\n\
2755 With no argument, display all currently requested auto-display expressions.\n\
2756 Use \"undisplay\" to cancel display requests previously made."));
2758 add_cmd ("display", class_vars
, enable_display_command
, _("\
2759 Enable some expressions to be displayed when program stops.\n\
2760 Usage: enable display [NUM]...\n\
2761 Arguments are the code numbers of the expressions to resume displaying.\n\
2762 No argument means enable all automatic-display expressions.\n\
2763 Do \"info display\" to see current list of code numbers."), &enablelist
);
2765 add_cmd ("display", class_vars
, disable_display_command
, _("\
2766 Disable some expressions to be displayed when program stops.\n\
2767 Usage: disable display [NUM]...\n\
2768 Arguments are the code numbers of the expressions to stop displaying.\n\
2769 No argument means disable all automatic-display expressions.\n\
2770 Do \"info display\" to see current list of code numbers."), &disablelist
);
2772 add_cmd ("display", class_vars
, undisplay_command
, _("\
2773 Cancel some expressions to be displayed when program stops.\n\
2774 Usage: delete display [NUM]...\n\
2775 Arguments are the code numbers of the expressions to stop displaying.\n\
2776 No argument means cancel all automatic-display expressions.\n\
2777 Do \"info display\" to see current list of code numbers."), &deletelist
);
2779 add_com ("printf", class_vars
, printf_command
, _("\
2780 Formatted printing, like the C \"printf\" function.\n\
2781 Usage: printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
2782 This supports most C printf format specifications, like %s, %d, etc."));
2784 add_com ("output", class_vars
, output_command
, _("\
2785 Like \"print\" but don't put in value history and don't print newline.\n\
2786 Usage: output EXP\n\
2787 This is useful in user-defined commands."));
2789 add_prefix_cmd ("set", class_vars
, set_command
, _("\
2790 Evaluate expression EXP and assign result to variable VAR\n\
2791 Usage: set VAR = EXP\n\
2792 This uses assignment syntax appropriate for the current language\n\
2793 (VAR = EXP or VAR := EXP for example).\n\
2794 VAR may be a debugger \"convenience\" variable (names starting\n\
2795 with $), a register (a few standard names starting with $), or an actual\n\
2796 variable in the program being debugged. EXP is any valid expression.\n\
2797 Use \"set variable\" for variables with names identical to set subcommands.\n\
2799 With a subcommand, this command modifies parts of the gdb environment.\n\
2800 You can see these environment settings with the \"show\" command."),
2801 &setlist
, "set ", 1, &cmdlist
);
2803 add_com ("assign", class_vars
, set_command
, _("\
2804 Evaluate expression EXP and assign result to variable VAR\n\
2805 Usage: assign VAR = EXP\n\
2806 This uses assignment syntax appropriate for the current language\n\
2807 (VAR = EXP or VAR := EXP for example).\n\
2808 VAR may be a debugger \"convenience\" variable (names starting\n\
2809 with $), a register (a few standard names starting with $), or an actual\n\
2810 variable in the program being debugged. EXP is any valid expression.\n\
2811 Use \"set variable\" for variables with names identical to set subcommands.\n\
2812 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2813 You can see these environment settings with the \"show\" command."));
2815 /* "call" is the same as "set", but handy for dbx users to call fns. */
2816 c
= add_com ("call", class_vars
, call_command
, _("\
2817 Call a function in the program.\n\
2819 The argument is the function name and arguments, in the notation of the\n\
2820 current working language. The result is printed and saved in the value\n\
2821 history, if it is not void."));
2822 set_cmd_completer_handle_brkchars (c
, print_command_completer
);
2824 add_cmd ("variable", class_vars
, set_command
, _("\
2825 Evaluate expression EXP and assign result to variable VAR\n\
2826 Usage: set variable VAR = EXP\n\
2827 This uses assignment syntax appropriate for the current language\n\
2828 (VAR = EXP or VAR := EXP for example).\n\
2829 VAR may be a debugger \"convenience\" variable (names starting\n\
2830 with $), a register (a few standard names starting with $), or an actual\n\
2831 variable in the program being debugged. EXP is any valid expression.\n\
2832 This may usually be abbreviated to simply \"set\"."),
2834 add_alias_cmd ("var", "variable", class_vars
, 0, &setlist
);
2836 const auto print_opts
= make_value_print_options_def_group (nullptr);
2838 static const std::string print_help
= gdb::option::build_help (N_("\
2839 Print value of expression EXP.\n\
2840 Usage: print [[OPTION]... --] [/FMT] [EXP]\n\
2844 Note: because this command accepts arbitrary expressions, if you\n\
2845 specify any command option, you must use a double dash (\"--\")\n\
2846 to mark the end of option processing. E.g.: \"print -o -- myobj\".\n\
2848 Variables accessible are those of the lexical environment of the selected\n\
2849 stack frame, plus all those whose scope is global or an entire file.\n\
2851 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2852 $$NUM refers to NUM'th value back from the last one.\n\
2853 Names starting with $ refer to registers (with the values they would have\n\
2854 if the program were to return to the stack frame now selected, restoring\n\
2855 all registers saved by frames farther in) or else to debugger\n\
2856 \"convenience\" variables (any such name not a known register).\n\
2857 Use assignment expressions to give values to convenience variables.\n\
2859 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2860 @ is a binary operator for treating consecutive data objects\n\
2861 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2862 element is FOO, whose second element is stored in the space following\n\
2863 where FOO is stored, etc. FOO must be an expression whose value\n\
2864 resides in memory.\n\
2866 EXP may be preceded with /FMT, where FMT is a format letter\n\
2867 but no count or size letter (see \"x\" command)."),
2870 c
= add_com ("print", class_vars
, print_command
, print_help
.c_str ());
2871 set_cmd_completer_handle_brkchars (c
, print_command_completer
);
2872 add_com_alias ("p", "print", class_vars
, 1);
2873 add_com_alias ("inspect", "print", class_vars
, 1);
2875 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class
,
2876 &max_symbolic_offset
, _("\
2877 Set the largest offset that will be printed in <SYMBOL+1234> form."), _("\
2878 Show the largest offset that will be printed in <SYMBOL+1234> form."), _("\
2879 Tell GDB to only display the symbolic form of an address if the\n\
2880 offset between the closest earlier symbol and the address is less than\n\
2881 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
2882 to always print the symbolic form of an address if any symbol precedes\n\
2883 it. Zero is equivalent to \"unlimited\"."),
2885 show_max_symbolic_offset
,
2886 &setprintlist
, &showprintlist
);
2887 add_setshow_boolean_cmd ("symbol-filename", no_class
,
2888 &print_symbol_filename
, _("\
2889 Set printing of source filename and line number with <SYMBOL>."), _("\
2890 Show printing of source filename and line number with <SYMBOL>."), NULL
,
2892 show_print_symbol_filename
,
2893 &setprintlist
, &showprintlist
);
2895 add_com ("eval", no_class
, eval_command
, _("\
2896 Construct a GDB command and then evaluate it.\n\
2897 Usage: eval \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
2898 Convert the arguments to a string as \"printf\" would, but then\n\
2899 treat this string as a command line, and evaluate it."));