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
, false, &name
,
533 &offset
, &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
, "%+d", 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 bool do_demangle
, /* IN */
568 bool prefer_sym_over_minsym
, /* IN */
569 std::string
*name
, /* OUT */
570 int *offset
, /* OUT */
571 std::string
*filename
, /* OUT */
573 int *unmapped
) /* OUT */
575 struct bound_minimal_symbol msymbol
;
576 struct symbol
*symbol
;
577 CORE_ADDR name_location
= 0;
578 struct obj_section
*section
= NULL
;
579 const char *name_temp
= "";
581 /* Let's say it is mapped (not unmapped). */
584 /* Determine if the address is in an overlay, and whether it is
586 if (overlay_debugging
)
588 section
= find_pc_overlay (addr
);
589 if (pc_in_unmapped_range (addr
, section
))
592 addr
= overlay_mapped_address (addr
, section
);
596 /* Try to find the address in both the symbol table and the minsyms.
597 In most cases, we'll prefer to use the symbol instead of the
598 minsym. However, there are cases (see below) where we'll choose
599 to use the minsym instead. */
601 /* This is defective in the sense that it only finds text symbols. So
602 really this is kind of pointless--we should make sure that the
603 minimal symbols have everything we need (by changing that we could
604 save some memory, but for many debug format--ELF/DWARF or
605 anything/stabs--it would be inconvenient to eliminate those minimal
607 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
608 symbol
= find_pc_sect_function (addr
, section
);
612 /* If this is a function (i.e. a code address), strip out any
613 non-address bits. For instance, display a pointer to the
614 first instruction of a Thumb function as <function>; the
615 second instruction will be <function+2>, even though the
616 pointer is <function+3>. This matches the ISA behavior. */
617 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
619 name_location
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (symbol
));
620 if (do_demangle
|| asm_demangle
)
621 name_temp
= SYMBOL_PRINT_NAME (symbol
);
623 name_temp
= SYMBOL_LINKAGE_NAME (symbol
);
626 if (msymbol
.minsym
!= NULL
627 && MSYMBOL_HAS_SIZE (msymbol
.minsym
)
628 && MSYMBOL_SIZE (msymbol
.minsym
) == 0
629 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text
630 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text_gnu_ifunc
631 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_file_text
)
632 msymbol
.minsym
= NULL
;
634 if (msymbol
.minsym
!= NULL
)
636 /* Use the minsym if no symbol is found.
638 Additionally, use the minsym instead of a (found) symbol if
639 the following conditions all hold:
640 1) The prefer_sym_over_minsym flag is false.
641 2) The minsym address is identical to that of the address under
643 3) The symbol address is not identical to that of the address
644 under consideration. */
645 if (symbol
== NULL
||
646 (!prefer_sym_over_minsym
647 && BMSYMBOL_VALUE_ADDRESS (msymbol
) == addr
648 && name_location
!= addr
))
650 /* If this is a function (i.e. a code address), strip out any
651 non-address bits. For instance, display a pointer to the
652 first instruction of a Thumb function as <function>; the
653 second instruction will be <function+2>, even though the
654 pointer is <function+3>. This matches the ISA behavior. */
655 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_text
656 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_text_gnu_ifunc
657 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_text
658 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
659 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
662 name_location
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
663 if (do_demangle
|| asm_demangle
)
664 name_temp
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
666 name_temp
= MSYMBOL_LINKAGE_NAME (msymbol
.minsym
);
669 if (symbol
== NULL
&& msymbol
.minsym
== NULL
)
672 /* If the nearest symbol is too far away, don't print anything symbolic. */
674 /* For when CORE_ADDR is larger than unsigned int, we do math in
675 CORE_ADDR. But when we detect unsigned wraparound in the
676 CORE_ADDR math, we ignore this test and print the offset,
677 because addr+max_symbolic_offset has wrapped through the end
678 of the address space back to the beginning, giving bogus comparison. */
679 if (addr
> name_location
+ max_symbolic_offset
680 && name_location
+ max_symbolic_offset
> name_location
)
683 *offset
= (LONGEST
) addr
- name_location
;
687 if (print_symbol_filename
)
689 struct symtab_and_line sal
;
691 sal
= find_pc_sect_line (addr
, section
, 0);
695 *filename
= symtab_to_filename_for_display (sal
.symtab
);
703 /* Print address ADDR symbolically on STREAM.
704 First print it as a number. Then perhaps print
705 <SYMBOL + OFFSET> after the number. */
708 print_address (struct gdbarch
*gdbarch
,
709 CORE_ADDR addr
, struct ui_file
*stream
)
711 fputs_styled (paddress (gdbarch
, addr
), address_style
.style (), stream
);
712 print_address_symbolic (gdbarch
, addr
, stream
, asm_demangle
, " ");
715 /* Return a prefix for instruction address:
716 "=> " for current instruction, else " ". */
719 pc_prefix (CORE_ADDR addr
)
721 if (has_stack_frames ())
723 struct frame_info
*frame
;
726 frame
= get_selected_frame (NULL
);
727 if (get_frame_pc_if_available (frame
, &pc
) && pc
== addr
)
733 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
734 controls whether to print the symbolic name "raw" or demangled.
735 Return non-zero if anything was printed; zero otherwise. */
738 print_address_demangle (const struct value_print_options
*opts
,
739 struct gdbarch
*gdbarch
, CORE_ADDR addr
,
740 struct ui_file
*stream
, int do_demangle
)
742 if (opts
->addressprint
)
744 fputs_styled (paddress (gdbarch
, addr
), address_style
.style (), stream
);
745 print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, " ");
749 return print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, "");
755 /* Find the address of the instruction that is INST_COUNT instructions before
756 the instruction at ADDR.
757 Since some architectures have variable-length instructions, we can't just
758 simply subtract INST_COUNT * INSN_LEN from ADDR. Instead, we use line
759 number information to locate the nearest known instruction boundary,
760 and disassemble forward from there. If we go out of the symbol range
761 during disassembling, we return the lowest address we've got so far and
762 set the number of instructions read to INST_READ. */
765 find_instruction_backward (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
766 int inst_count
, int *inst_read
)
768 /* The vector PCS is used to store instruction addresses within
770 CORE_ADDR loop_start
, loop_end
, p
;
771 std::vector
<CORE_ADDR
> pcs
;
772 struct symtab_and_line sal
;
775 loop_start
= loop_end
= addr
;
777 /* In each iteration of the outer loop, we get a pc range that ends before
778 LOOP_START, then we count and store every instruction address of the range
779 iterated in the loop.
780 If the number of instructions counted reaches INST_COUNT, return the
781 stored address that is located INST_COUNT instructions back from ADDR.
782 If INST_COUNT is not reached, we subtract the number of counted
783 instructions from INST_COUNT, and go to the next iteration. */
787 sal
= find_pc_sect_line (loop_start
, NULL
, 1);
790 /* We reach here when line info is not available. In this case,
791 we print a message and just exit the loop. The return value
792 is calculated after the loop. */
793 printf_filtered (_("No line number information available "
796 print_address (gdbarch
, loop_start
- 1, gdb_stdout
);
797 printf_filtered ("\n");
801 loop_end
= loop_start
;
804 /* This loop pushes instruction addresses in the range from
805 LOOP_START to LOOP_END. */
806 for (p
= loop_start
; p
< loop_end
;)
809 p
+= gdb_insn_length (gdbarch
, p
);
812 inst_count
-= pcs
.size ();
813 *inst_read
+= pcs
.size ();
815 while (inst_count
> 0);
817 /* After the loop, the vector PCS has instruction addresses of the last
818 source line we processed, and INST_COUNT has a negative value.
819 We return the address at the index of -INST_COUNT in the vector for
821 Let's assume the following instruction addresses and run 'x/-4i 0x400e'.
831 find_instruction_backward is called with INST_COUNT = 4 and expected to
832 return 0x4001. When we reach here, INST_COUNT is set to -1 because
833 it was subtracted by 2 (from Line Y) and 3 (from Line X). The value
834 4001 is located at the index 1 of the last iterated line (= Line X),
835 which is simply calculated by -INST_COUNT.
836 The case when the length of PCS is 0 means that we reached an area for
837 which line info is not available. In such case, we return LOOP_START,
838 which was the lowest instruction address that had line info. */
839 p
= pcs
.size () > 0 ? pcs
[-inst_count
] : loop_start
;
841 /* INST_READ includes all instruction addresses in a pc range. Need to
842 exclude the beginning part up to the address we're returning. That
843 is, exclude {0x4000} in the example above. */
845 *inst_read
+= inst_count
;
850 /* Backward read LEN bytes of target memory from address MEMADDR + LEN,
851 placing the results in GDB's memory from MYADDR + LEN. Returns
852 a count of the bytes actually read. */
855 read_memory_backward (struct gdbarch
*gdbarch
,
856 CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
859 int nread
; /* Number of bytes actually read. */
861 /* First try a complete read. */
862 errcode
= target_read_memory (memaddr
, myaddr
, len
);
870 /* Loop, reading one byte at a time until we get as much as we can. */
873 for (nread
= 0; nread
< len
; ++nread
)
875 errcode
= target_read_memory (--memaddr
, --myaddr
, 1);
878 /* The read was unsuccessful, so exit the loop. */
879 printf_filtered (_("Cannot access memory at address %s\n"),
880 paddress (gdbarch
, memaddr
));
888 /* Returns true if X (which is LEN bytes wide) is the number zero. */
891 integer_is_zero (const gdb_byte
*x
, int len
)
895 while (i
< len
&& x
[i
] == 0)
900 /* Find the start address of a string in which ADDR is included.
901 Basically we search for '\0' and return the next address,
902 but if OPTIONS->PRINT_MAX is smaller than the length of a string,
903 we stop searching and return the address to print characters as many as
904 PRINT_MAX from the string. */
907 find_string_backward (struct gdbarch
*gdbarch
,
908 CORE_ADDR addr
, int count
, int char_size
,
909 const struct value_print_options
*options
,
910 int *strings_counted
)
912 const int chunk_size
= 0x20;
915 int chars_to_read
= chunk_size
;
916 int chars_counted
= 0;
917 int count_original
= count
;
918 CORE_ADDR string_start_addr
= addr
;
920 gdb_assert (char_size
== 1 || char_size
== 2 || char_size
== 4);
921 gdb::byte_vector
buffer (chars_to_read
* char_size
);
922 while (count
> 0 && read_error
== 0)
926 addr
-= chars_to_read
* char_size
;
927 chars_read
= read_memory_backward (gdbarch
, addr
, buffer
.data (),
928 chars_to_read
* char_size
);
929 chars_read
/= char_size
;
930 read_error
= (chars_read
== chars_to_read
) ? 0 : 1;
931 /* Searching for '\0' from the end of buffer in backward direction. */
932 for (i
= 0; i
< chars_read
&& count
> 0 ; ++i
, ++chars_counted
)
934 int offset
= (chars_to_read
- i
- 1) * char_size
;
936 if (integer_is_zero (&buffer
[offset
], char_size
)
937 || chars_counted
== options
->print_max
)
939 /* Found '\0' or reached print_max. As OFFSET is the offset to
940 '\0', we add CHAR_SIZE to return the start address of
943 string_start_addr
= addr
+ offset
+ char_size
;
949 /* Update STRINGS_COUNTED with the actual number of loaded strings. */
950 *strings_counted
= count_original
- count
;
954 /* In error case, STRING_START_ADDR is pointing to the string that
955 was last successfully loaded. Rewind the partially loaded string. */
956 string_start_addr
-= chars_counted
* char_size
;
959 return string_start_addr
;
962 /* Examine data at address ADDR in format FMT.
963 Fetch it from memory and print on gdb_stdout. */
966 do_examine (struct format_data fmt
, struct gdbarch
*gdbarch
, CORE_ADDR addr
)
971 struct type
*val_type
= NULL
;
974 struct value_print_options opts
;
975 int need_to_update_next_address
= 0;
976 CORE_ADDR addr_rewound
= 0;
981 next_gdbarch
= gdbarch
;
984 /* Instruction format implies fetch single bytes
985 regardless of the specified size.
986 The case of strings is handled in decode_format, only explicit
987 size operator are not changed to 'b'. */
993 /* Pick the appropriate size for an address. */
994 if (gdbarch_ptr_bit (next_gdbarch
) == 64)
996 else if (gdbarch_ptr_bit (next_gdbarch
) == 32)
998 else if (gdbarch_ptr_bit (next_gdbarch
) == 16)
1001 /* Bad value for gdbarch_ptr_bit. */
1002 internal_error (__FILE__
, __LINE__
,
1003 _("failed internal consistency check"));
1007 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1008 else if (size
== 'h')
1009 val_type
= builtin_type (next_gdbarch
)->builtin_int16
;
1010 else if (size
== 'w')
1011 val_type
= builtin_type (next_gdbarch
)->builtin_int32
;
1012 else if (size
== 'g')
1013 val_type
= builtin_type (next_gdbarch
)->builtin_int64
;
1017 struct type
*char_type
= NULL
;
1019 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
1020 if type is not found. */
1022 char_type
= builtin_type (next_gdbarch
)->builtin_char16
;
1023 else if (size
== 'w')
1024 char_type
= builtin_type (next_gdbarch
)->builtin_char32
;
1026 val_type
= char_type
;
1029 if (size
!= '\0' && size
!= 'b')
1030 warning (_("Unable to display strings with "
1031 "size '%c', using 'b' instead."), size
);
1033 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1042 if (format
== 's' || format
== 'i')
1045 get_formatted_print_options (&opts
, format
);
1049 /* This is the negative repeat count case.
1050 We rewind the address based on the given repeat count and format,
1051 then examine memory from there in forward direction. */
1056 next_address
= find_instruction_backward (gdbarch
, addr
, count
,
1059 else if (format
== 's')
1061 next_address
= find_string_backward (gdbarch
, addr
, count
,
1062 TYPE_LENGTH (val_type
),
1067 next_address
= addr
- count
* TYPE_LENGTH (val_type
);
1070 /* The following call to print_formatted updates next_address in every
1071 iteration. In backward case, we store the start address here
1072 and update next_address with it before exiting the function. */
1073 addr_rewound
= (format
== 's'
1074 ? next_address
- TYPE_LENGTH (val_type
)
1076 need_to_update_next_address
= 1;
1079 /* Print as many objects as specified in COUNT, at most maxelts per line,
1080 with the address of the next one at the start of each line. */
1086 fputs_filtered (pc_prefix (next_address
), gdb_stdout
);
1087 print_address (next_gdbarch
, next_address
, gdb_stdout
);
1088 printf_filtered (":");
1093 printf_filtered ("\t");
1094 /* Note that print_formatted sets next_address for the next
1096 last_examine_address
= next_address
;
1098 /* The value to be displayed is not fetched greedily.
1099 Instead, to avoid the possibility of a fetched value not
1100 being used, its retrieval is delayed until the print code
1101 uses it. When examining an instruction stream, the
1102 disassembler will perform its own memory fetch using just
1103 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
1104 the disassembler be modified so that LAST_EXAMINE_VALUE
1105 is left with the byte sequence from the last complete
1106 instruction fetched from memory? */
1108 = release_value (value_at_lazy (val_type
, next_address
));
1110 print_formatted (last_examine_value
.get (), size
, &opts
, gdb_stdout
);
1112 /* Display any branch delay slots following the final insn. */
1113 if (format
== 'i' && count
== 1)
1114 count
+= branch_delay_insns
;
1116 printf_filtered ("\n");
1119 if (need_to_update_next_address
)
1120 next_address
= addr_rewound
;
1124 validate_format (struct format_data fmt
, const char *cmdname
)
1127 error (_("Size letters are meaningless in \"%s\" command."), cmdname
);
1129 error (_("Item count other than 1 is meaningless in \"%s\" command."),
1131 if (fmt
.format
== 'i')
1132 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
1133 fmt
.format
, cmdname
);
1136 /* Parse print command format string into *OPTS and update *EXPP.
1137 CMDNAME should name the current command. */
1140 print_command_parse_format (const char **expp
, const char *cmdname
,
1141 value_print_options
*opts
)
1143 const char *exp
= *expp
;
1145 if (exp
&& *exp
== '/')
1150 fmt
= decode_format (&exp
, last_format
, 0);
1151 validate_format (fmt
, cmdname
);
1152 last_format
= fmt
.format
;
1154 opts
->format
= fmt
.format
;
1155 opts
->raw
= fmt
.raw
;
1166 /* See valprint.h. */
1169 print_value (value
*val
, const value_print_options
&opts
)
1171 int histindex
= record_latest_value (val
);
1173 annotate_value_history_begin (histindex
, value_type (val
));
1175 printf_filtered ("$%d = ", histindex
);
1177 annotate_value_history_value ();
1179 print_formatted (val
, 0, &opts
, gdb_stdout
);
1180 printf_filtered ("\n");
1182 annotate_value_history_end ();
1185 /* Implementation of the "print" and "call" commands. */
1188 print_command_1 (const char *args
, int voidprint
)
1191 value_print_options print_opts
;
1193 get_user_print_options (&print_opts
);
1194 /* Override global settings with explicit options, if any. */
1195 auto group
= make_value_print_options_def_group (&print_opts
);
1196 gdb::option::process_options
1197 (&args
, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER
, group
);
1199 print_command_parse_format (&args
, "print", &print_opts
);
1201 const char *exp
= args
;
1203 if (exp
!= nullptr && *exp
)
1205 expression_up expr
= parse_expression (exp
);
1206 val
= evaluate_expression (expr
.get ());
1209 val
= access_value_history (0);
1211 if (voidprint
|| (val
&& value_type (val
) &&
1212 TYPE_CODE (value_type (val
)) != TYPE_CODE_VOID
))
1213 print_value (val
, print_opts
);
1216 /* See valprint.h. */
1219 print_command_completer (struct cmd_list_element
*ignore
,
1220 completion_tracker
&tracker
,
1221 const char *text
, const char * /*word*/)
1223 const auto group
= make_value_print_options_def_group (nullptr);
1224 if (gdb::option::complete_options
1225 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER
, group
))
1228 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
1229 expression_completer (ignore
, tracker
, text
, word
);
1233 print_command (const char *exp
, int from_tty
)
1235 print_command_1 (exp
, 1);
1238 /* Same as print, except it doesn't print void results. */
1240 call_command (const char *exp
, int from_tty
)
1242 print_command_1 (exp
, 0);
1245 /* Implementation of the "output" command. */
1248 output_command (const char *exp
, int from_tty
)
1252 struct format_data fmt
;
1253 struct value_print_options opts
;
1258 if (exp
&& *exp
== '/')
1261 fmt
= decode_format (&exp
, 0, 0);
1262 validate_format (fmt
, "output");
1263 format
= fmt
.format
;
1266 expression_up expr
= parse_expression (exp
);
1268 val
= evaluate_expression (expr
.get ());
1270 annotate_value_begin (value_type (val
));
1272 get_formatted_print_options (&opts
, format
);
1274 print_formatted (val
, fmt
.size
, &opts
, gdb_stdout
);
1276 annotate_value_end ();
1279 gdb_flush (gdb_stdout
);
1283 set_command (const char *exp
, int from_tty
)
1285 expression_up expr
= parse_expression (exp
);
1287 if (expr
->nelts
>= 1)
1288 switch (expr
->elts
[0].opcode
)
1290 case UNOP_PREINCREMENT
:
1291 case UNOP_POSTINCREMENT
:
1292 case UNOP_PREDECREMENT
:
1293 case UNOP_POSTDECREMENT
:
1295 case BINOP_ASSIGN_MODIFY
:
1300 (_("Expression is not an assignment (and might have no effect)"));
1303 evaluate_expression (expr
.get ());
1307 info_symbol_command (const char *arg
, int from_tty
)
1309 struct minimal_symbol
*msymbol
;
1310 struct obj_section
*osect
;
1311 CORE_ADDR addr
, sect_addr
;
1313 unsigned int offset
;
1316 error_no_arg (_("address"));
1318 addr
= parse_and_eval_address (arg
);
1319 for (objfile
*objfile
: current_program_space
->objfiles ())
1320 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
1322 /* Only process each object file once, even if there's a separate
1324 if (objfile
->separate_debug_objfile_backlink
)
1327 sect_addr
= overlay_mapped_address (addr
, osect
);
1329 if (obj_section_addr (osect
) <= sect_addr
1330 && sect_addr
< obj_section_endaddr (osect
)
1332 = lookup_minimal_symbol_by_pc_section (sect_addr
,
1335 const char *obj_name
, *mapped
, *sec_name
, *msym_name
;
1336 const char *loc_string
;
1339 offset
= sect_addr
- MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
);
1340 mapped
= section_is_mapped (osect
) ? _("mapped") : _("unmapped");
1341 sec_name
= osect
->the_bfd_section
->name
;
1342 msym_name
= MSYMBOL_PRINT_NAME (msymbol
);
1344 /* Don't print the offset if it is zero.
1345 We assume there's no need to handle i18n of "sym + offset". */
1346 std::string string_holder
;
1349 string_holder
= string_printf ("%s + %u", msym_name
, offset
);
1350 loc_string
= string_holder
.c_str ();
1353 loc_string
= msym_name
;
1355 gdb_assert (osect
->objfile
&& objfile_name (osect
->objfile
));
1356 obj_name
= objfile_name (osect
->objfile
);
1358 if (MULTI_OBJFILE_P ())
1359 if (pc_in_unmapped_range (addr
, osect
))
1360 if (section_is_overlay (osect
))
1361 printf_filtered (_("%s in load address range of "
1362 "%s overlay section %s of %s\n"),
1363 loc_string
, mapped
, sec_name
, obj_name
);
1365 printf_filtered (_("%s in load address range of "
1366 "section %s of %s\n"),
1367 loc_string
, sec_name
, obj_name
);
1369 if (section_is_overlay (osect
))
1370 printf_filtered (_("%s in %s overlay section %s of %s\n"),
1371 loc_string
, mapped
, sec_name
, obj_name
);
1373 printf_filtered (_("%s in section %s of %s\n"),
1374 loc_string
, sec_name
, obj_name
);
1376 if (pc_in_unmapped_range (addr
, osect
))
1377 if (section_is_overlay (osect
))
1378 printf_filtered (_("%s in load address range of %s overlay "
1380 loc_string
, mapped
, sec_name
);
1383 (_("%s in load address range of section %s\n"),
1384 loc_string
, sec_name
);
1386 if (section_is_overlay (osect
))
1387 printf_filtered (_("%s in %s overlay section %s\n"),
1388 loc_string
, mapped
, sec_name
);
1390 printf_filtered (_("%s in section %s\n"),
1391 loc_string
, sec_name
);
1395 printf_filtered (_("No symbol matches %s.\n"), arg
);
1399 info_address_command (const char *exp
, int from_tty
)
1401 struct gdbarch
*gdbarch
;
1404 struct bound_minimal_symbol msymbol
;
1406 struct obj_section
*section
;
1407 CORE_ADDR load_addr
, context_pc
= 0;
1408 struct field_of_this_result is_a_field_of_this
;
1411 error (_("Argument required."));
1413 sym
= lookup_symbol (exp
, get_selected_block (&context_pc
), VAR_DOMAIN
,
1414 &is_a_field_of_this
).symbol
;
1417 if (is_a_field_of_this
.type
!= NULL
)
1419 printf_filtered ("Symbol \"");
1420 fprintf_symbol_filtered (gdb_stdout
, exp
,
1421 current_language
->la_language
, DMGL_ANSI
);
1422 printf_filtered ("\" is a field of the local class variable ");
1423 if (current_language
->la_language
== language_objc
)
1424 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1426 printf_filtered ("`this'\n");
1430 msymbol
= lookup_bound_minimal_symbol (exp
);
1432 if (msymbol
.minsym
!= NULL
)
1434 struct objfile
*objfile
= msymbol
.objfile
;
1436 gdbarch
= get_objfile_arch (objfile
);
1437 load_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
1439 printf_filtered ("Symbol \"");
1440 fprintf_symbol_filtered (gdb_stdout
, exp
,
1441 current_language
->la_language
, DMGL_ANSI
);
1442 printf_filtered ("\" is at ");
1443 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1445 printf_filtered (" in a file compiled without debugging");
1446 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
1447 if (section_is_overlay (section
))
1449 load_addr
= overlay_unmapped_address (load_addr
, section
);
1450 printf_filtered (",\n -- loaded at ");
1451 fputs_styled (paddress (gdbarch
, load_addr
),
1452 address_style
.style (),
1454 printf_filtered (" in overlay section %s",
1455 section
->the_bfd_section
->name
);
1457 printf_filtered (".\n");
1460 error (_("No symbol \"%s\" in current context."), exp
);
1464 printf_filtered ("Symbol \"");
1465 fprintf_symbol_filtered (gdb_stdout
, SYMBOL_PRINT_NAME (sym
),
1466 current_language
->la_language
, DMGL_ANSI
);
1467 printf_filtered ("\" is ");
1468 val
= SYMBOL_VALUE (sym
);
1469 if (SYMBOL_OBJFILE_OWNED (sym
))
1470 section
= SYMBOL_OBJ_SECTION (symbol_objfile (sym
), sym
);
1473 gdbarch
= symbol_arch (sym
);
1475 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
1477 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, context_pc
,
1479 printf_filtered (".\n");
1483 switch (SYMBOL_CLASS (sym
))
1486 case LOC_CONST_BYTES
:
1487 printf_filtered ("constant");
1491 printf_filtered ("a label at address ");
1492 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1493 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1495 if (section_is_overlay (section
))
1497 load_addr
= overlay_unmapped_address (load_addr
, section
);
1498 printf_filtered (",\n -- loaded at ");
1499 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1501 printf_filtered (" in overlay section %s",
1502 section
->the_bfd_section
->name
);
1507 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
1510 /* GDBARCH is the architecture associated with the objfile the symbol
1511 is defined in; the target architecture may be different, and may
1512 provide additional registers. However, we do not know the target
1513 architecture at this point. We assume the objfile architecture
1514 will contain all the standard registers that occur in debug info
1516 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1518 if (SYMBOL_IS_ARGUMENT (sym
))
1519 printf_filtered (_("an argument in register %s"),
1520 gdbarch_register_name (gdbarch
, regno
));
1522 printf_filtered (_("a variable in register %s"),
1523 gdbarch_register_name (gdbarch
, regno
));
1527 printf_filtered (_("static storage at address "));
1528 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1529 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1531 if (section_is_overlay (section
))
1533 load_addr
= overlay_unmapped_address (load_addr
, section
);
1534 printf_filtered (_(",\n -- loaded at "));
1535 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1537 printf_filtered (_(" in overlay section %s"),
1538 section
->the_bfd_section
->name
);
1542 case LOC_REGPARM_ADDR
:
1543 /* Note comment at LOC_REGISTER. */
1544 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1545 printf_filtered (_("address of an argument in register %s"),
1546 gdbarch_register_name (gdbarch
, regno
));
1550 printf_filtered (_("an argument at offset %ld"), val
);
1554 printf_filtered (_("a local variable at frame offset %ld"), val
);
1558 printf_filtered (_("a reference argument at offset %ld"), val
);
1562 printf_filtered (_("a typedef"));
1566 printf_filtered (_("a function at address "));
1567 load_addr
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
1568 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1570 if (section_is_overlay (section
))
1572 load_addr
= overlay_unmapped_address (load_addr
, section
);
1573 printf_filtered (_(",\n -- loaded at "));
1574 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1576 printf_filtered (_(" in overlay section %s"),
1577 section
->the_bfd_section
->name
);
1581 case LOC_UNRESOLVED
:
1583 struct bound_minimal_symbol msym
;
1585 msym
= lookup_bound_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
));
1586 if (msym
.minsym
== NULL
)
1587 printf_filtered ("unresolved");
1590 section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
1593 && (section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
1595 load_addr
= MSYMBOL_VALUE_RAW_ADDRESS (msym
.minsym
);
1596 printf_filtered (_("a thread-local variable at offset %s "
1597 "in the thread-local storage for `%s'"),
1598 paddress (gdbarch
, load_addr
),
1599 objfile_name (section
->objfile
));
1603 load_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
1604 printf_filtered (_("static storage at address "));
1605 fputs_styled (paddress (gdbarch
, load_addr
),
1606 address_style
.style (), gdb_stdout
);
1607 if (section_is_overlay (section
))
1609 load_addr
= overlay_unmapped_address (load_addr
, section
);
1610 printf_filtered (_(",\n -- loaded at "));
1611 fputs_styled (paddress (gdbarch
, load_addr
),
1612 address_style
.style (),
1614 printf_filtered (_(" in overlay section %s"),
1615 section
->the_bfd_section
->name
);
1622 case LOC_OPTIMIZED_OUT
:
1623 printf_filtered (_("optimized out"));
1627 printf_filtered (_("of unknown (botched) type"));
1630 printf_filtered (".\n");
1635 x_command (const char *exp
, int from_tty
)
1637 struct format_data fmt
;
1640 fmt
.format
= last_format
? last_format
: 'x';
1641 fmt
.size
= last_size
;
1645 /* If there is no expression and no format, use the most recent
1647 if (exp
== nullptr && last_count
> 0)
1648 fmt
.count
= last_count
;
1650 if (exp
&& *exp
== '/')
1652 const char *tmp
= exp
+ 1;
1654 fmt
= decode_format (&tmp
, last_format
, last_size
);
1658 last_count
= fmt
.count
;
1660 /* If we have an expression, evaluate it and use it as the address. */
1662 if (exp
!= 0 && *exp
!= 0)
1664 expression_up expr
= parse_expression (exp
);
1665 /* Cause expression not to be there any more if this command is
1666 repeated with Newline. But don't clobber a user-defined
1667 command's definition. */
1669 set_repeat_arguments ("");
1670 val
= evaluate_expression (expr
.get ());
1671 if (TYPE_IS_REFERENCE (value_type (val
)))
1672 val
= coerce_ref (val
);
1673 /* In rvalue contexts, such as this, functions are coerced into
1674 pointers to functions. This makes "x/i main" work. */
1675 if (/* last_format == 'i' && */
1676 TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
1677 && VALUE_LVAL (val
) == lval_memory
)
1678 next_address
= value_address (val
);
1680 next_address
= value_as_address (val
);
1682 next_gdbarch
= expr
->gdbarch
;
1686 error_no_arg (_("starting display address"));
1688 do_examine (fmt
, next_gdbarch
, next_address
);
1690 /* If the examine succeeds, we remember its size and format for next
1691 time. Set last_size to 'b' for strings. */
1692 if (fmt
.format
== 's')
1695 last_size
= fmt
.size
;
1696 last_format
= fmt
.format
;
1698 /* Set a couple of internal variables if appropriate. */
1699 if (last_examine_value
!= nullptr)
1701 /* Make last address examined available to the user as $_. Use
1702 the correct pointer type. */
1703 struct type
*pointer_type
1704 = lookup_pointer_type (value_type (last_examine_value
.get ()));
1705 set_internalvar (lookup_internalvar ("_"),
1706 value_from_pointer (pointer_type
,
1707 last_examine_address
));
1709 /* Make contents of last address examined available to the user
1710 as $__. If the last value has not been fetched from memory
1711 then don't fetch it now; instead mark it by voiding the $__
1713 if (value_lazy (last_examine_value
.get ()))
1714 clear_internalvar (lookup_internalvar ("__"));
1716 set_internalvar (lookup_internalvar ("__"), last_examine_value
.get ());
1721 /* Add an expression to the auto-display chain.
1722 Specify the expression. */
1725 display_command (const char *arg
, int from_tty
)
1727 struct format_data fmt
;
1728 struct display
*newobj
;
1729 const char *exp
= arg
;
1740 fmt
= decode_format (&exp
, 0, 0);
1741 if (fmt
.size
&& fmt
.format
== 0)
1743 if (fmt
.format
== 'i' || fmt
.format
== 's')
1754 innermost_block_tracker tracker
;
1755 expression_up expr
= parse_expression (exp
, &tracker
);
1757 newobj
= new display ();
1759 newobj
->exp_string
= xstrdup (exp
);
1760 newobj
->exp
= std::move (expr
);
1761 newobj
->block
= tracker
.block ();
1762 newobj
->pspace
= current_program_space
;
1763 newobj
->number
= ++display_number
;
1764 newobj
->format
= fmt
;
1765 newobj
->enabled_p
= 1;
1766 newobj
->next
= NULL
;
1768 if (display_chain
== NULL
)
1769 display_chain
= newobj
;
1772 struct display
*last
;
1774 for (last
= display_chain
; last
->next
!= NULL
; last
= last
->next
)
1776 last
->next
= newobj
;
1780 do_one_display (newobj
);
1786 free_display (struct display
*d
)
1788 xfree (d
->exp_string
);
1792 /* Clear out the display_chain. Done when new symtabs are loaded,
1793 since this invalidates the types stored in many expressions. */
1796 clear_displays (void)
1800 while ((d
= display_chain
) != NULL
)
1802 display_chain
= d
->next
;
1807 /* Delete the auto-display DISPLAY. */
1810 delete_display (struct display
*display
)
1814 gdb_assert (display
!= NULL
);
1816 if (display_chain
== display
)
1817 display_chain
= display
->next
;
1820 if (d
->next
== display
)
1822 d
->next
= display
->next
;
1826 free_display (display
);
1829 /* Call FUNCTION on each of the displays whose numbers are given in
1830 ARGS. DATA is passed unmodified to FUNCTION. */
1833 map_display_numbers (const char *args
,
1834 void (*function
) (struct display
*,
1841 error_no_arg (_("one or more display numbers"));
1843 number_or_range_parser
parser (args
);
1845 while (!parser
.finished ())
1847 const char *p
= parser
.cur_tok ();
1849 num
= parser
.get_number ();
1851 warning (_("bad display number at or near '%s'"), p
);
1854 struct display
*d
, *tmp
;
1856 ALL_DISPLAYS_SAFE (d
, tmp
)
1857 if (d
->number
== num
)
1860 printf_unfiltered (_("No display number %d.\n"), num
);
1867 /* Callback for map_display_numbers, that deletes a display. */
1870 do_delete_display (struct display
*d
, void *data
)
1875 /* "undisplay" command. */
1878 undisplay_command (const char *args
, int from_tty
)
1882 if (query (_("Delete all auto-display expressions? ")))
1888 map_display_numbers (args
, do_delete_display
, NULL
);
1892 /* Display a single auto-display.
1893 Do nothing if the display cannot be printed in the current context,
1894 or if the display is disabled. */
1897 do_one_display (struct display
*d
)
1899 int within_current_scope
;
1901 if (d
->enabled_p
== 0)
1904 /* The expression carries the architecture that was used at parse time.
1905 This is a problem if the expression depends on architecture features
1906 (e.g. register numbers), and the current architecture is now different.
1907 For example, a display statement like "display/i $pc" is expected to
1908 display the PC register of the current architecture, not the arch at
1909 the time the display command was given. Therefore, we re-parse the
1910 expression if the current architecture has changed. */
1911 if (d
->exp
!= NULL
&& d
->exp
->gdbarch
!= get_current_arch ())
1922 innermost_block_tracker tracker
;
1923 d
->exp
= parse_expression (d
->exp_string
, &tracker
);
1924 d
->block
= tracker
.block ();
1926 catch (const gdb_exception
&ex
)
1928 /* Can't re-parse the expression. Disable this display item. */
1930 warning (_("Unable to display \"%s\": %s"),
1931 d
->exp_string
, ex
.what ());
1938 if (d
->pspace
== current_program_space
)
1939 within_current_scope
= contained_in (get_selected_block (0), d
->block
,
1942 within_current_scope
= 0;
1945 within_current_scope
= 1;
1946 if (!within_current_scope
)
1949 scoped_restore save_display_number
1950 = make_scoped_restore (¤t_display_number
, d
->number
);
1952 annotate_display_begin ();
1953 printf_filtered ("%d", d
->number
);
1954 annotate_display_number_end ();
1955 printf_filtered (": ");
1959 annotate_display_format ();
1961 printf_filtered ("x/");
1962 if (d
->format
.count
!= 1)
1963 printf_filtered ("%d", d
->format
.count
);
1964 printf_filtered ("%c", d
->format
.format
);
1965 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1966 printf_filtered ("%c", d
->format
.size
);
1967 printf_filtered (" ");
1969 annotate_display_expression ();
1971 puts_filtered (d
->exp_string
);
1972 annotate_display_expression_end ();
1974 if (d
->format
.count
!= 1 || d
->format
.format
== 'i')
1975 printf_filtered ("\n");
1977 printf_filtered (" ");
1979 annotate_display_value ();
1986 val
= evaluate_expression (d
->exp
.get ());
1987 addr
= value_as_address (val
);
1988 if (d
->format
.format
== 'i')
1989 addr
= gdbarch_addr_bits_remove (d
->exp
->gdbarch
, addr
);
1990 do_examine (d
->format
, d
->exp
->gdbarch
, addr
);
1992 catch (const gdb_exception_error
&ex
)
1994 fprintf_filtered (gdb_stdout
, _("<error: %s>\n"),
2000 struct value_print_options opts
;
2002 annotate_display_format ();
2004 if (d
->format
.format
)
2005 printf_filtered ("/%c ", d
->format
.format
);
2007 annotate_display_expression ();
2009 puts_filtered (d
->exp_string
);
2010 annotate_display_expression_end ();
2012 printf_filtered (" = ");
2014 annotate_display_expression ();
2016 get_formatted_print_options (&opts
, d
->format
.format
);
2017 opts
.raw
= d
->format
.raw
;
2023 val
= evaluate_expression (d
->exp
.get ());
2024 print_formatted (val
, d
->format
.size
, &opts
, gdb_stdout
);
2026 catch (const gdb_exception_error
&ex
)
2028 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.what ());
2031 printf_filtered ("\n");
2034 annotate_display_end ();
2036 gdb_flush (gdb_stdout
);
2039 /* Display all of the values on the auto-display chain which can be
2040 evaluated in the current scope. */
2047 for (d
= display_chain
; d
; d
= d
->next
)
2051 /* Delete the auto-display which we were in the process of displaying.
2052 This is done when there is an error or a signal. */
2055 disable_display (int num
)
2059 for (d
= display_chain
; d
; d
= d
->next
)
2060 if (d
->number
== num
)
2065 printf_unfiltered (_("No display number %d.\n"), num
);
2069 disable_current_display (void)
2071 if (current_display_number
>= 0)
2073 disable_display (current_display_number
);
2074 fprintf_unfiltered (gdb_stderr
,
2075 _("Disabling display %d to "
2076 "avoid infinite recursion.\n"),
2077 current_display_number
);
2079 current_display_number
= -1;
2083 info_display_command (const char *ignore
, int from_tty
)
2088 printf_unfiltered (_("There are no auto-display expressions now.\n"));
2090 printf_filtered (_("Auto-display expressions now in effect:\n\
2091 Num Enb Expression\n"));
2093 for (d
= display_chain
; d
; d
= d
->next
)
2095 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
2097 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
2099 else if (d
->format
.format
)
2100 printf_filtered ("/%c ", d
->format
.format
);
2101 puts_filtered (d
->exp_string
);
2102 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
, true))
2103 printf_filtered (_(" (cannot be evaluated in the current context)"));
2104 printf_filtered ("\n");
2108 /* Callback fo map_display_numbers, that enables or disables the
2109 passed in display D. */
2112 do_enable_disable_display (struct display
*d
, void *data
)
2114 d
->enabled_p
= *(int *) data
;
2117 /* Implamentation of both the "disable display" and "enable display"
2118 commands. ENABLE decides what to do. */
2121 enable_disable_display_command (const char *args
, int from_tty
, int enable
)
2128 d
->enabled_p
= enable
;
2132 map_display_numbers (args
, do_enable_disable_display
, &enable
);
2135 /* The "enable display" command. */
2138 enable_display_command (const char *args
, int from_tty
)
2140 enable_disable_display_command (args
, from_tty
, 1);
2143 /* The "disable display" command. */
2146 disable_display_command (const char *args
, int from_tty
)
2148 enable_disable_display_command (args
, from_tty
, 0);
2151 /* display_chain items point to blocks and expressions. Some expressions in
2152 turn may point to symbols.
2153 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
2154 obstack_free'd when a shared library is unloaded.
2155 Clear pointers that are about to become dangling.
2156 Both .exp and .block fields will be restored next time we need to display
2157 an item by re-parsing .exp_string field in the new execution context. */
2160 clear_dangling_display_expressions (struct objfile
*objfile
)
2163 struct program_space
*pspace
;
2165 /* With no symbol file we cannot have a block or expression from it. */
2166 if (objfile
== NULL
)
2168 pspace
= objfile
->pspace
;
2169 if (objfile
->separate_debug_objfile_backlink
)
2171 objfile
= objfile
->separate_debug_objfile_backlink
;
2172 gdb_assert (objfile
->pspace
== pspace
);
2175 for (d
= display_chain
; d
!= NULL
; d
= d
->next
)
2177 if (d
->pspace
!= pspace
)
2180 if (lookup_objfile_from_block (d
->block
) == objfile
2181 || (d
->exp
!= NULL
&& exp_uses_objfile (d
->exp
.get (), objfile
)))
2190 /* Print the value in stack frame FRAME of a variable specified by a
2191 struct symbol. NAME is the name to print; if NULL then VAR's print
2192 name will be used. STREAM is the ui_file on which to print the
2193 value. INDENT specifies the number of indent levels to print
2194 before printing the variable name.
2196 This function invalidates FRAME. */
2199 print_variable_and_value (const char *name
, struct symbol
*var
,
2200 struct frame_info
*frame
,
2201 struct ui_file
*stream
, int indent
)
2205 name
= SYMBOL_PRINT_NAME (var
);
2207 fputs_filtered (n_spaces (2 * indent
), stream
);
2208 fputs_styled (name
, variable_name_style
.style (), stream
);
2209 fputs_filtered (" = ", stream
);
2214 struct value_print_options opts
;
2216 /* READ_VAR_VALUE needs a block in order to deal with non-local
2217 references (i.e. to handle nested functions). In this context, we
2218 print variables that are local to this frame, so we can avoid passing
2220 val
= read_var_value (var
, NULL
, frame
);
2221 get_user_print_options (&opts
);
2223 common_val_print (val
, stream
, indent
, &opts
, current_language
);
2225 /* common_val_print invalidates FRAME when a pretty printer calls inferior
2229 catch (const gdb_exception_error
&except
)
2231 fprintf_filtered (stream
, "<error reading variable %s (%s)>", name
,
2235 fprintf_filtered (stream
, "\n");
2238 /* Subroutine of ui_printf to simplify it.
2239 Print VALUE to STREAM using FORMAT.
2240 VALUE is a C-style string either on the target or
2241 in a GDB internal variable. */
2244 printf_c_string (struct ui_file
*stream
, const char *format
,
2245 struct value
*value
)
2247 const gdb_byte
*str
;
2249 if (VALUE_LVAL (value
) == lval_internalvar
2250 && c_is_string_type_p (value_type (value
)))
2252 size_t len
= TYPE_LENGTH (value_type (value
));
2254 /* Copy the internal var value to TEM_STR and append a terminating null
2255 character. This protects against corrupted C-style strings that lack
2256 the terminating null char. It also allows Ada-style strings (not
2257 null terminated) to be printed without problems. */
2258 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ 1);
2260 memcpy (tem_str
, value_contents (value
), len
);
2266 CORE_ADDR tem
= value_as_address (value
);;
2271 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2272 fprintf_filtered (stream
, format
, "(null)");
2277 /* This is a %s argument. Find the length of the string. */
2280 for (len
= 0;; len
++)
2285 read_memory (tem
+ len
, &c
, 1);
2290 /* Copy the string contents into a string inside GDB. */
2291 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ 1);
2294 read_memory (tem
, tem_str
, len
);
2300 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2301 fprintf_filtered (stream
, format
, (char *) str
);
2305 /* Subroutine of ui_printf to simplify it.
2306 Print VALUE to STREAM using FORMAT.
2307 VALUE is a wide C-style string on the target or
2308 in a GDB internal variable. */
2311 printf_wide_c_string (struct ui_file
*stream
, const char *format
,
2312 struct value
*value
)
2314 const gdb_byte
*str
;
2316 struct gdbarch
*gdbarch
= get_type_arch (value_type (value
));
2317 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2318 "wchar_t", NULL
, 0);
2319 int wcwidth
= TYPE_LENGTH (wctype
);
2321 if (VALUE_LVAL (value
) == lval_internalvar
2322 && c_is_string_type_p (value_type (value
)))
2324 str
= value_contents (value
);
2325 len
= TYPE_LENGTH (value_type (value
));
2329 CORE_ADDR tem
= value_as_address (value
);
2334 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2335 fprintf_filtered (stream
, format
, "(null)");
2340 /* This is a %s argument. Find the length of the string. */
2341 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2342 gdb_byte
*buf
= (gdb_byte
*) alloca (wcwidth
);
2344 for (len
= 0;; len
+= wcwidth
)
2347 read_memory (tem
+ len
, buf
, wcwidth
);
2348 if (extract_unsigned_integer (buf
, wcwidth
, byte_order
) == 0)
2352 /* Copy the string contents into a string inside GDB. */
2353 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ wcwidth
);
2356 read_memory (tem
, tem_str
, len
);
2357 memset (&tem_str
[len
], 0, wcwidth
);
2361 auto_obstack output
;
2363 convert_between_encodings (target_wide_charset (gdbarch
),
2366 &output
, translit_char
);
2367 obstack_grow_str0 (&output
, "");
2370 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2371 fprintf_filtered (stream
, format
, obstack_base (&output
));
2375 /* Subroutine of ui_printf to simplify it.
2376 Print VALUE, a floating point value, to STREAM using FORMAT. */
2379 printf_floating (struct ui_file
*stream
, const char *format
,
2380 struct value
*value
, enum argclass argclass
)
2382 /* Parameter data. */
2383 struct type
*param_type
= value_type (value
);
2384 struct gdbarch
*gdbarch
= get_type_arch (param_type
);
2386 /* Determine target type corresponding to the format string. */
2387 struct type
*fmt_type
;
2391 fmt_type
= builtin_type (gdbarch
)->builtin_double
;
2393 case long_double_arg
:
2394 fmt_type
= builtin_type (gdbarch
)->builtin_long_double
;
2396 case dec32float_arg
:
2397 fmt_type
= builtin_type (gdbarch
)->builtin_decfloat
;
2399 case dec64float_arg
:
2400 fmt_type
= builtin_type (gdbarch
)->builtin_decdouble
;
2402 case dec128float_arg
:
2403 fmt_type
= builtin_type (gdbarch
)->builtin_declong
;
2406 gdb_assert_not_reached ("unexpected argument class");
2409 /* To match the traditional GDB behavior, the conversion is
2410 done differently depending on the type of the parameter:
2412 - if the parameter has floating-point type, it's value
2413 is converted to the target type;
2415 - otherwise, if the parameter has a type that is of the
2416 same size as a built-in floating-point type, the value
2417 bytes are interpreted as if they were of that type, and
2418 then converted to the target type (this is not done for
2419 decimal floating-point argument classes);
2421 - otherwise, if the source value has an integer value,
2422 it's value is converted to the target type;
2424 - otherwise, an error is raised.
2426 In either case, the result of the conversion is a byte buffer
2427 formatted in the target format for the target type. */
2429 if (TYPE_CODE (fmt_type
) == TYPE_CODE_FLT
)
2431 param_type
= float_type_from_length (param_type
);
2432 if (param_type
!= value_type (value
))
2433 value
= value_from_contents (param_type
, value_contents (value
));
2436 value
= value_cast (fmt_type
, value
);
2438 /* Convert the value to a string and print it. */
2440 = target_float_to_string (value_contents (value
), fmt_type
, format
);
2441 fputs_filtered (str
.c_str (), stream
);
2444 /* Subroutine of ui_printf to simplify it.
2445 Print VALUE, a target pointer, to STREAM using FORMAT. */
2448 printf_pointer (struct ui_file
*stream
, const char *format
,
2449 struct value
*value
)
2451 /* We avoid the host's %p because pointers are too
2452 likely to be the wrong size. The only interesting
2453 modifier for %p is a width; extract that, and then
2454 handle %p as glibc would: %#x or a literal "(nil)". */
2458 #ifdef PRINTF_HAS_LONG_LONG
2459 long long val
= value_as_long (value
);
2461 long val
= value_as_long (value
);
2464 fmt
= (char *) alloca (strlen (format
) + 5);
2466 /* Copy up to the leading %. */
2471 int is_percent
= (*p
== '%');
2486 /* Copy any width or flags. Only the "-" flag is valid for pointers
2487 -- see the format_pieces constructor. */
2488 while (*p
== '-' || (*p
>= '0' && *p
< '9'))
2491 gdb_assert (*p
== 'p' && *(p
+ 1) == '\0');
2494 #ifdef PRINTF_HAS_LONG_LONG
2501 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2502 fprintf_filtered (stream
, fmt
, val
);
2510 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2511 fprintf_filtered (stream
, fmt
, "(nil)");
2516 /* printf "printf format string" ARG to STREAM. */
2519 ui_printf (const char *arg
, struct ui_file
*stream
)
2521 const char *s
= arg
;
2522 std::vector
<struct value
*> val_args
;
2525 error_no_arg (_("format-control string and values to print"));
2527 s
= skip_spaces (s
);
2529 /* A format string should follow, enveloped in double quotes. */
2531 error (_("Bad format string, missing '\"'."));
2533 format_pieces
fpieces (&s
);
2536 error (_("Bad format string, non-terminated '\"'."));
2538 s
= skip_spaces (s
);
2540 if (*s
!= ',' && *s
!= 0)
2541 error (_("Invalid argument syntax"));
2545 s
= skip_spaces (s
);
2550 const char *current_substring
;
2553 for (auto &&piece
: fpieces
)
2554 if (piece
.argclass
!= literal_piece
)
2557 /* Now, parse all arguments and evaluate them.
2558 Store the VALUEs in VAL_ARGS. */
2565 val_args
.push_back (parse_to_comma_and_eval (&s1
));
2572 if (val_args
.size () != nargs_wanted
)
2573 error (_("Wrong number of arguments for specified format-string"));
2575 /* Now actually print them. */
2577 for (auto &&piece
: fpieces
)
2579 current_substring
= piece
.string
;
2580 switch (piece
.argclass
)
2583 printf_c_string (stream
, current_substring
, val_args
[i
]);
2585 case wide_string_arg
:
2586 printf_wide_c_string (stream
, current_substring
, val_args
[i
]);
2590 struct gdbarch
*gdbarch
2591 = get_type_arch (value_type (val_args
[i
]));
2592 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2593 "wchar_t", NULL
, 0);
2594 struct type
*valtype
;
2595 const gdb_byte
*bytes
;
2597 valtype
= value_type (val_args
[i
]);
2598 if (TYPE_LENGTH (valtype
) != TYPE_LENGTH (wctype
)
2599 || TYPE_CODE (valtype
) != TYPE_CODE_INT
)
2600 error (_("expected wchar_t argument for %%lc"));
2602 bytes
= value_contents (val_args
[i
]);
2604 auto_obstack output
;
2606 convert_between_encodings (target_wide_charset (gdbarch
),
2608 bytes
, TYPE_LENGTH (valtype
),
2609 TYPE_LENGTH (valtype
),
2610 &output
, translit_char
);
2611 obstack_grow_str0 (&output
, "");
2614 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2615 fprintf_filtered (stream
, current_substring
,
2616 obstack_base (&output
));
2621 #ifdef PRINTF_HAS_LONG_LONG
2623 long long val
= value_as_long (val_args
[i
]);
2626 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2627 fprintf_filtered (stream
, current_substring
, val
);
2632 error (_("long long not supported in printf"));
2636 int val
= value_as_long (val_args
[i
]);
2639 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2640 fprintf_filtered (stream
, current_substring
, val
);
2646 long val
= value_as_long (val_args
[i
]);
2649 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2650 fprintf_filtered (stream
, current_substring
, val
);
2654 /* Handles floating-point values. */
2656 case long_double_arg
:
2657 case dec32float_arg
:
2658 case dec64float_arg
:
2659 case dec128float_arg
:
2660 printf_floating (stream
, current_substring
, val_args
[i
],
2664 printf_pointer (stream
, current_substring
, val_args
[i
]);
2667 /* Print a portion of the format string that has no
2668 directives. Note that this will not include any
2669 ordinary %-specs, but it might include "%%". That is
2670 why we use printf_filtered and not puts_filtered here.
2671 Also, we pass a dummy argument because some platforms
2672 have modified GCC to include -Wformat-security by
2673 default, which will warn here if there is no
2676 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2677 fprintf_filtered (stream
, current_substring
, 0);
2681 internal_error (__FILE__
, __LINE__
,
2682 _("failed internal consistency check"));
2684 /* Maybe advance to the next argument. */
2685 if (piece
.argclass
!= literal_piece
)
2691 /* Implement the "printf" command. */
2694 printf_command (const char *arg
, int from_tty
)
2696 ui_printf (arg
, gdb_stdout
);
2697 reset_terminal_style (gdb_stdout
);
2699 gdb_flush (gdb_stdout
);
2702 /* Implement the "eval" command. */
2705 eval_command (const char *arg
, int from_tty
)
2709 ui_printf (arg
, &stb
);
2711 std::string expanded
= insert_user_defined_cmd_args (stb
.c_str ());
2713 execute_command (expanded
.c_str (), from_tty
);
2717 _initialize_printcmd (void)
2719 struct cmd_list_element
*c
;
2721 current_display_number
= -1;
2723 gdb::observers::free_objfile
.attach (clear_dangling_display_expressions
);
2725 add_info ("address", info_address_command
,
2726 _("Describe where symbol SYM is stored.\n\
2727 Usage: info address SYM"));
2729 add_info ("symbol", info_symbol_command
, _("\
2730 Describe what symbol is at location ADDR.\n\
2731 Usage: info symbol ADDR\n\
2732 Only for symbols with fixed locations (global or static scope)."));
2734 add_com ("x", class_vars
, x_command
, _("\
2735 Examine memory: x/FMT ADDRESS.\n\
2736 ADDRESS is an expression for the memory address to examine.\n\
2737 FMT is a repeat count followed by a format letter and a size letter.\n\
2738 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2739 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2740 and z(hex, zero padded on the left).\n\
2741 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2742 The specified number of objects of the specified size are printed\n\
2743 according to the format. If a negative number is specified, memory is\n\
2744 examined backward from the address.\n\n\
2745 Defaults for format and size letters are those previously used.\n\
2746 Default count is 1. Default address is following last thing printed\n\
2747 with this command or \"print\"."));
2749 add_info ("display", info_display_command
, _("\
2750 Expressions to display when program stops, with code numbers.\n\
2751 Usage: info display"));
2753 add_cmd ("undisplay", class_vars
, undisplay_command
, _("\
2754 Cancel some expressions to be displayed when program stops.\n\
2755 Usage: undisplay [NUM]...\n\
2756 Arguments are the code numbers of the expressions to stop displaying.\n\
2757 No argument means cancel all automatic-display expressions.\n\
2758 \"delete display\" has the same effect as this command.\n\
2759 Do \"info display\" to see current list of code numbers."),
2762 add_com ("display", class_vars
, display_command
, _("\
2763 Print value of expression EXP each time the program stops.\n\
2764 Usage: display[/FMT] EXP\n\
2765 /FMT may be used before EXP as in the \"print\" command.\n\
2766 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2767 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2768 and examining is done as in the \"x\" command.\n\n\
2769 With no argument, display all currently requested auto-display expressions.\n\
2770 Use \"undisplay\" to cancel display requests previously made."));
2772 add_cmd ("display", class_vars
, enable_display_command
, _("\
2773 Enable some expressions to be displayed when program stops.\n\
2774 Usage: enable display [NUM]...\n\
2775 Arguments are the code numbers of the expressions to resume displaying.\n\
2776 No argument means enable all automatic-display expressions.\n\
2777 Do \"info display\" to see current list of code numbers."), &enablelist
);
2779 add_cmd ("display", class_vars
, disable_display_command
, _("\
2780 Disable some expressions to be displayed when program stops.\n\
2781 Usage: disable display [NUM]...\n\
2782 Arguments are the code numbers of the expressions to stop displaying.\n\
2783 No argument means disable all automatic-display expressions.\n\
2784 Do \"info display\" to see current list of code numbers."), &disablelist
);
2786 add_cmd ("display", class_vars
, undisplay_command
, _("\
2787 Cancel some expressions to be displayed when program stops.\n\
2788 Usage: delete display [NUM]...\n\
2789 Arguments are the code numbers of the expressions to stop displaying.\n\
2790 No argument means cancel all automatic-display expressions.\n\
2791 Do \"info display\" to see current list of code numbers."), &deletelist
);
2793 add_com ("printf", class_vars
, printf_command
, _("\
2794 Formatted printing, like the C \"printf\" function.\n\
2795 Usage: printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
2796 This supports most C printf format specifications, like %s, %d, etc."));
2798 add_com ("output", class_vars
, output_command
, _("\
2799 Like \"print\" but don't put in value history and don't print newline.\n\
2800 Usage: output EXP\n\
2801 This is useful in user-defined commands."));
2803 add_prefix_cmd ("set", class_vars
, set_command
, _("\
2804 Evaluate expression EXP and assign result to variable VAR.\n\
2805 Usage: set 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\
2813 With a subcommand, this command modifies parts of the gdb environment.\n\
2814 You can see these environment settings with the \"show\" command."),
2815 &setlist
, "set ", 1, &cmdlist
);
2817 add_com ("assign", class_vars
, set_command
, _("\
2818 Evaluate expression EXP and assign result to variable VAR.\n\
2819 Usage: assign VAR = EXP\n\
2820 This uses assignment syntax appropriate for the current language\n\
2821 (VAR = EXP or VAR := EXP for example).\n\
2822 VAR may be a debugger \"convenience\" variable (names starting\n\
2823 with $), a register (a few standard names starting with $), or an actual\n\
2824 variable in the program being debugged. EXP is any valid expression.\n\
2825 Use \"set variable\" for variables with names identical to set subcommands.\n\
2826 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2827 You can see these environment settings with the \"show\" command."));
2829 /* "call" is the same as "set", but handy for dbx users to call fns. */
2830 c
= add_com ("call", class_vars
, call_command
, _("\
2831 Call a function in the program.\n\
2833 The argument is the function name and arguments, in the notation of the\n\
2834 current working language. The result is printed and saved in the value\n\
2835 history, if it is not void."));
2836 set_cmd_completer_handle_brkchars (c
, print_command_completer
);
2838 add_cmd ("variable", class_vars
, set_command
, _("\
2839 Evaluate expression EXP and assign result to variable VAR.\n\
2840 Usage: set variable VAR = EXP\n\
2841 This uses assignment syntax appropriate for the current language\n\
2842 (VAR = EXP or VAR := EXP for example).\n\
2843 VAR may be a debugger \"convenience\" variable (names starting\n\
2844 with $), a register (a few standard names starting with $), or an actual\n\
2845 variable in the program being debugged. EXP is any valid expression.\n\
2846 This may usually be abbreviated to simply \"set\"."),
2848 add_alias_cmd ("var", "variable", class_vars
, 0, &setlist
);
2850 const auto print_opts
= make_value_print_options_def_group (nullptr);
2852 static const std::string print_help
= gdb::option::build_help (_("\
2853 Print value of expression EXP.\n\
2854 Usage: print [[OPTION]... --] [/FMT] [EXP]\n\
2859 Note: because this command accepts arbitrary expressions, if you\n\
2860 specify any command option, you must use a double dash (\"--\")\n\
2861 to mark the end of option processing. E.g.: \"print -o -- myobj\".\n\
2863 Variables accessible are those of the lexical environment of the selected\n\
2864 stack frame, plus all those whose scope is global or an entire file.\n\
2866 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2867 $$NUM refers to NUM'th value back from the last one.\n\
2868 Names starting with $ refer to registers (with the values they would have\n\
2869 if the program were to return to the stack frame now selected, restoring\n\
2870 all registers saved by frames farther in) or else to debugger\n\
2871 \"convenience\" variables (any such name not a known register).\n\
2872 Use assignment expressions to give values to convenience variables.\n\
2874 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2875 @ is a binary operator for treating consecutive data objects\n\
2876 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2877 element is FOO, whose second element is stored in the space following\n\
2878 where FOO is stored, etc. FOO must be an expression whose value\n\
2879 resides in memory.\n\
2881 EXP may be preceded with /FMT, where FMT is a format letter\n\
2882 but no count or size letter (see \"x\" command)."),
2885 c
= add_com ("print", class_vars
, print_command
, print_help
.c_str ());
2886 set_cmd_completer_handle_brkchars (c
, print_command_completer
);
2887 add_com_alias ("p", "print", class_vars
, 1);
2888 add_com_alias ("inspect", "print", class_vars
, 1);
2890 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class
,
2891 &max_symbolic_offset
, _("\
2892 Set the largest offset that will be printed in <SYMBOL+1234> form."), _("\
2893 Show the largest offset that will be printed in <SYMBOL+1234> form."), _("\
2894 Tell GDB to only display the symbolic form of an address if the\n\
2895 offset between the closest earlier symbol and the address is less than\n\
2896 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
2897 to always print the symbolic form of an address if any symbol precedes\n\
2898 it. Zero is equivalent to \"unlimited\"."),
2900 show_max_symbolic_offset
,
2901 &setprintlist
, &showprintlist
);
2902 add_setshow_boolean_cmd ("symbol-filename", no_class
,
2903 &print_symbol_filename
, _("\
2904 Set printing of source filename and line number with <SYMBOL>."), _("\
2905 Show printing of source filename and line number with <SYMBOL>."), NULL
,
2907 show_print_symbol_filename
,
2908 &setprintlist
, &showprintlist
);
2910 add_com ("eval", no_class
, eval_command
, _("\
2911 Construct a GDB command and then evaluate it.\n\
2912 Usage: eval \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
2913 Convert the arguments to a string as \"printf\" would, but then\n\
2914 treat this string as a command line, and evaluate it."));