1 /* Print values for GNU debugger GDB.
3 Copyright (C) 1986-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "expression.h"
31 #include "breakpoint.h"
33 #include "gdb-demangle.h"
36 #include "symfile.h" /* for overlay functions */
37 #include "objfiles.h" /* ditto */
38 #include "completer.h" /* for completion functions */
42 #include "target-float.h"
43 #include "observable.h"
45 #include "parser-defs.h"
47 #include "arch-utils.h"
48 #include "cli/cli-utils.h"
49 #include "cli/cli-option.h"
50 #include "cli/cli-script.h"
51 #include "cli/cli-style.h"
52 #include "gdbsupport/format.h"
54 #include "gdbsupport/byte-vector.h"
55 #include "gdbsupport/gdb_optional.h"
57 /* Last specified output format. */
59 static char last_format
= 0;
61 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
63 static char last_size
= 'w';
65 /* Last specified count for the 'x' command. */
67 static int last_count
;
69 /* Default address to examine next, and associated architecture. */
71 static struct gdbarch
*next_gdbarch
;
72 static CORE_ADDR next_address
;
74 /* Number of delay instructions following current disassembled insn. */
76 static int branch_delay_insns
;
78 /* Last address examined. */
80 static CORE_ADDR last_examine_address
;
82 /* Contents of last address examined.
83 This is not valid past the end of the `x' command! */
85 static value_ref_ptr last_examine_value
;
87 /* Largest offset between a symbolic value and an address, that will be
88 printed as `0x1234 <symbol+offset>'. */
90 static unsigned int max_symbolic_offset
= UINT_MAX
;
92 show_max_symbolic_offset (struct ui_file
*file
, int from_tty
,
93 struct cmd_list_element
*c
, const char *value
)
95 fprintf_filtered (file
,
96 _("The largest offset that will be "
97 "printed in <symbol+1234> form is %s.\n"),
101 /* Append the source filename and linenumber of the symbol when
102 printing a symbolic value as `<symbol at filename:linenum>' if set. */
103 static bool print_symbol_filename
= false;
105 show_print_symbol_filename (struct ui_file
*file
, int from_tty
,
106 struct cmd_list_element
*c
, const char *value
)
108 fprintf_filtered (file
, _("Printing of source filename and "
109 "line number with <symbol> is %s.\n"),
113 /* Number of auto-display expression currently being displayed.
114 So that we can disable it if we get a signal within it.
115 -1 when not doing one. */
117 static int current_display_number
;
119 /* Last allocated display number. */
121 static int display_number
;
125 display (const char *exp_string_
, expression_up
&&exp_
,
126 const struct format_data
&format_
, struct program_space
*pspace_
,
127 const struct block
*block_
)
128 : exp_string (exp_string_
),
129 exp (std::move (exp_
)),
130 number (++display_number
),
138 /* The expression as the user typed it. */
139 std::string exp_string
;
141 /* Expression to be evaluated and displayed. */
144 /* Item number of this auto-display item. */
147 /* Display format specified. */
148 struct format_data format
;
150 /* Program space associated with `block'. */
151 struct program_space
*pspace
;
153 /* Innermost block required by this expression when evaluated. */
154 const struct block
*block
;
156 /* Status of this display (enabled or disabled). */
160 /* Expressions whose values should be displayed automatically each
161 time the program stops. */
163 static std::vector
<std::unique_ptr
<struct display
>> all_displays
;
165 /* Prototypes for local functions. */
167 static void do_one_display (struct display
*);
170 /* Decode a format specification. *STRING_PTR should point to it.
171 OFORMAT and OSIZE are used as defaults for the format and size
172 if none are given in the format specification.
173 If OSIZE is zero, then the size field of the returned value
174 should be set only if a size is explicitly specified by the
176 The structure returned describes all the data
177 found in the specification. In addition, *STRING_PTR is advanced
178 past the specification and past all whitespace following it. */
180 static struct format_data
181 decode_format (const char **string_ptr
, int oformat
, int osize
)
183 struct format_data val
;
184 const char *p
= *string_ptr
;
196 if (*p
>= '0' && *p
<= '9')
197 val
.count
*= atoi (p
);
198 while (*p
>= '0' && *p
<= '9')
201 /* Now process size or format letters that follow. */
205 if (*p
== 'b' || *p
== 'h' || *p
== 'w' || *p
== 'g')
212 else if (*p
>= 'a' && *p
<= 'z')
218 *string_ptr
= skip_spaces (p
);
220 /* Set defaults for format and size if not specified. */
221 if (val
.format
== '?')
225 /* Neither has been specified. */
226 val
.format
= oformat
;
230 /* If a size is specified, any format makes a reasonable
231 default except 'i'. */
232 val
.format
= oformat
== 'i' ? 'x' : oformat
;
234 else if (val
.size
== '?')
238 /* Pick the appropriate size for an address. This is deferred
239 until do_examine when we know the actual architecture to use.
240 A special size value of 'a' is used to indicate this case. */
241 val
.size
= osize
? 'a' : osize
;
244 /* Floating point has to be word or giantword. */
245 if (osize
== 'w' || osize
== 'g')
248 /* Default it to giantword if the last used size is not
250 val
.size
= osize
? 'g' : osize
;
253 /* Characters default to one byte. */
254 val
.size
= osize
? 'b' : osize
;
257 /* Display strings with byte size chars unless explicitly
263 /* The default is the size most recently specified. */
270 /* Print value VAL on stream according to OPTIONS.
271 Do not end with a newline.
272 SIZE is the letter for the size of datum being printed.
273 This is used to pad hex numbers so they line up. SIZE is 0
274 for print / output and set for examine. */
277 print_formatted (struct value
*val
, int size
,
278 const struct value_print_options
*options
,
279 struct ui_file
*stream
)
281 struct type
*type
= check_typedef (value_type (val
));
282 int len
= TYPE_LENGTH (type
);
284 if (VALUE_LVAL (val
) == lval_memory
)
285 next_address
= value_address (val
) + len
;
289 switch (options
->format
)
293 struct type
*elttype
= value_type (val
);
295 next_address
= (value_address (val
)
296 + val_print_string (elttype
, NULL
,
297 value_address (val
), -1,
298 stream
, options
) * len
);
303 /* We often wrap here if there are long symbolic names. */
305 next_address
= (value_address (val
)
306 + gdb_print_insn (get_type_arch (type
),
307 value_address (val
), stream
,
308 &branch_delay_insns
));
313 if (options
->format
== 0 || options
->format
== 's'
314 || type
->code () == TYPE_CODE_REF
315 || type
->code () == TYPE_CODE_ARRAY
316 || type
->code () == TYPE_CODE_STRING
317 || type
->code () == TYPE_CODE_STRUCT
318 || type
->code () == TYPE_CODE_UNION
319 || type
->code () == TYPE_CODE_NAMESPACE
)
320 value_print (val
, stream
, options
);
322 /* User specified format, so don't look to the type to tell us
324 value_print_scalar_formatted (val
, options
, size
, stream
);
327 /* Return builtin floating point type of same length as TYPE.
328 If no such type is found, return TYPE itself. */
330 float_type_from_length (struct type
*type
)
332 struct gdbarch
*gdbarch
= get_type_arch (type
);
333 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
335 if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_float
))
336 type
= builtin
->builtin_float
;
337 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_double
))
338 type
= builtin
->builtin_double
;
339 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_long_double
))
340 type
= builtin
->builtin_long_double
;
345 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
346 according to OPTIONS and SIZE on STREAM. Formats s and i are not
347 supported at this level. */
350 print_scalar_formatted (const gdb_byte
*valaddr
, struct type
*type
,
351 const struct value_print_options
*options
,
352 int size
, struct ui_file
*stream
)
354 struct gdbarch
*gdbarch
= get_type_arch (type
);
355 unsigned int len
= TYPE_LENGTH (type
);
356 enum bfd_endian byte_order
= type_byte_order (type
);
358 /* String printing should go through val_print_scalar_formatted. */
359 gdb_assert (options
->format
!= 's');
361 /* If the value is a pointer, and pointers and addresses are not the
362 same, then at this point, the value's length (in target bytes) is
363 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
364 if (type
->code () == TYPE_CODE_PTR
)
365 len
= gdbarch_addr_bit (gdbarch
) / TARGET_CHAR_BIT
;
367 /* If we are printing it as unsigned, truncate it in case it is actually
368 a negative signed value (e.g. "print/u (short)-1" should print 65535
369 (if shorts are 16 bits) instead of 4294967295). */
370 if (options
->format
!= 'c'
371 && (options
->format
!= 'd' || TYPE_UNSIGNED (type
)))
373 if (len
< TYPE_LENGTH (type
) && byte_order
== BFD_ENDIAN_BIG
)
374 valaddr
+= TYPE_LENGTH (type
) - len
;
377 if (size
!= 0 && (options
->format
== 'x' || options
->format
== 't'))
379 /* Truncate to fit. */
396 error (_("Undefined output size \"%c\"."), size
);
398 if (newlen
< len
&& byte_order
== BFD_ENDIAN_BIG
)
399 valaddr
+= len
- newlen
;
403 /* Historically gdb has printed floats by first casting them to a
404 long, and then printing the long. PR cli/16242 suggests changing
405 this to using C-style hex float format.
407 Biased range types must also be unbiased here; the unbiasing is
408 done by unpack_long. */
409 gdb::byte_vector converted_bytes
;
410 /* Some cases below will unpack the value again. In the biased
411 range case, we want to avoid this, so we store the unpacked value
412 here for possible use later. */
413 gdb::optional
<LONGEST
> val_long
;
414 if ((type
->code () == TYPE_CODE_FLT
415 && (options
->format
== 'o'
416 || options
->format
== 'x'
417 || options
->format
== 't'
418 || options
->format
== 'z'
419 || options
->format
== 'd'
420 || options
->format
== 'u'))
421 || (type
->code () == TYPE_CODE_RANGE
&& type
->bounds ()->bias
!= 0))
423 val_long
.emplace (unpack_long (type
, valaddr
));
424 converted_bytes
.resize (TYPE_LENGTH (type
));
425 store_signed_integer (converted_bytes
.data (), TYPE_LENGTH (type
),
426 byte_order
, *val_long
);
427 valaddr
= converted_bytes
.data ();
430 /* Printing a non-float type as 'f' will interpret the data as if it were
431 of a floating-point type of the same length, if that exists. Otherwise,
432 the data is printed as integer. */
433 char format
= options
->format
;
434 if (format
== 'f' && type
->code () != TYPE_CODE_FLT
)
436 type
= float_type_from_length (type
);
437 if (type
->code () != TYPE_CODE_FLT
)
444 print_octal_chars (stream
, valaddr
, len
, byte_order
);
447 print_decimal_chars (stream
, valaddr
, len
, true, byte_order
);
450 print_decimal_chars (stream
, valaddr
, len
, false, byte_order
);
453 if (type
->code () != TYPE_CODE_FLT
)
455 print_decimal_chars (stream
, valaddr
, len
, !TYPE_UNSIGNED (type
),
461 print_floating (valaddr
, type
, stream
);
465 print_binary_chars (stream
, valaddr
, len
, byte_order
, size
> 0);
468 print_hex_chars (stream
, valaddr
, len
, byte_order
, size
> 0);
471 print_hex_chars (stream
, valaddr
, len
, byte_order
, true);
475 struct value_print_options opts
= *options
;
477 if (!val_long
.has_value ())
478 val_long
.emplace (unpack_long (type
, valaddr
));
481 if (TYPE_UNSIGNED (type
))
482 type
= builtin_type (gdbarch
)->builtin_true_unsigned_char
;
484 type
= builtin_type (gdbarch
)->builtin_true_char
;
486 value_print (value_from_longest (type
, *val_long
), stream
, &opts
);
492 if (!val_long
.has_value ())
493 val_long
.emplace (unpack_long (type
, valaddr
));
494 print_address (gdbarch
, *val_long
, stream
);
499 error (_("Undefined output format \"%c\"."), format
);
503 /* Specify default address for `x' command.
504 The `info lines' command uses this. */
507 set_next_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
509 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
511 next_gdbarch
= gdbarch
;
514 /* Make address available to the user as $_. */
515 set_internalvar (lookup_internalvar ("_"),
516 value_from_pointer (ptr_type
, addr
));
519 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
520 after LEADIN. Print nothing if no symbolic name is found nearby.
521 Optionally also print source file and line number, if available.
522 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
523 or to interpret it as a possible C++ name and convert it back to source
524 form. However note that DO_DEMANGLE can be overridden by the specific
525 settings of the demangle and asm_demangle variables. Returns
526 non-zero if anything was printed; zero otherwise. */
529 print_address_symbolic (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
530 struct ui_file
*stream
,
531 int do_demangle
, const char *leadin
)
533 std::string name
, filename
;
538 if (build_address_symbolic (gdbarch
, addr
, do_demangle
, false, &name
,
539 &offset
, &filename
, &line
, &unmapped
))
542 fputs_filtered (leadin
, stream
);
544 fputs_filtered ("<*", stream
);
546 fputs_filtered ("<", stream
);
547 fputs_styled (name
.c_str (), function_name_style
.style (), stream
);
549 fprintf_filtered (stream
, "%+d", offset
);
551 /* Append source filename and line number if desired. Give specific
552 line # of this addr, if we have it; else line # of the nearest symbol. */
553 if (print_symbol_filename
&& !filename
.empty ())
555 fputs_filtered (line
== -1 ? " in " : " at ", stream
);
556 fputs_styled (filename
.c_str (), file_name_style
.style (), stream
);
558 fprintf_filtered (stream
, ":%d", line
);
561 fputs_filtered ("*>", stream
);
563 fputs_filtered (">", stream
);
568 /* See valprint.h. */
571 build_address_symbolic (struct gdbarch
*gdbarch
,
572 CORE_ADDR addr
, /* IN */
573 bool do_demangle
, /* IN */
574 bool prefer_sym_over_minsym
, /* IN */
575 std::string
*name
, /* OUT */
576 int *offset
, /* OUT */
577 std::string
*filename
, /* OUT */
579 int *unmapped
) /* OUT */
581 struct bound_minimal_symbol msymbol
;
582 struct symbol
*symbol
;
583 CORE_ADDR name_location
= 0;
584 struct obj_section
*section
= NULL
;
585 const char *name_temp
= "";
587 /* Let's say it is mapped (not unmapped). */
590 /* Determine if the address is in an overlay, and whether it is
592 if (overlay_debugging
)
594 section
= find_pc_overlay (addr
);
595 if (pc_in_unmapped_range (addr
, section
))
598 addr
= overlay_mapped_address (addr
, section
);
602 /* Try to find the address in both the symbol table and the minsyms.
603 In most cases, we'll prefer to use the symbol instead of the
604 minsym. However, there are cases (see below) where we'll choose
605 to use the minsym instead. */
607 /* This is defective in the sense that it only finds text symbols. So
608 really this is kind of pointless--we should make sure that the
609 minimal symbols have everything we need (by changing that we could
610 save some memory, but for many debug format--ELF/DWARF or
611 anything/stabs--it would be inconvenient to eliminate those minimal
613 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
614 symbol
= find_pc_sect_function (addr
, section
);
618 /* If this is a function (i.e. a code address), strip out any
619 non-address bits. For instance, display a pointer to the
620 first instruction of a Thumb function as <function>; the
621 second instruction will be <function+2>, even though the
622 pointer is <function+3>. This matches the ISA behavior. */
623 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
625 name_location
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (symbol
));
626 if (do_demangle
|| asm_demangle
)
627 name_temp
= symbol
->print_name ();
629 name_temp
= symbol
->linkage_name ();
632 if (msymbol
.minsym
!= NULL
633 && MSYMBOL_HAS_SIZE (msymbol
.minsym
)
634 && MSYMBOL_SIZE (msymbol
.minsym
) == 0
635 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text
636 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text_gnu_ifunc
637 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_file_text
)
638 msymbol
.minsym
= NULL
;
640 if (msymbol
.minsym
!= NULL
)
642 /* Use the minsym if no symbol is found.
644 Additionally, use the minsym instead of a (found) symbol if
645 the following conditions all hold:
646 1) The prefer_sym_over_minsym flag is false.
647 2) The minsym address is identical to that of the address under
649 3) The symbol address is not identical to that of the address
650 under consideration. */
651 if (symbol
== NULL
||
652 (!prefer_sym_over_minsym
653 && BMSYMBOL_VALUE_ADDRESS (msymbol
) == addr
654 && name_location
!= addr
))
656 /* If this is a function (i.e. a code address), strip out any
657 non-address bits. For instance, display a pointer to the
658 first instruction of a Thumb function as <function>; the
659 second instruction will be <function+2>, even though the
660 pointer is <function+3>. This matches the ISA behavior. */
661 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_text
662 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_text_gnu_ifunc
663 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_text
664 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
665 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
668 name_location
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
669 if (do_demangle
|| asm_demangle
)
670 name_temp
= msymbol
.minsym
->print_name ();
672 name_temp
= msymbol
.minsym
->linkage_name ();
675 if (symbol
== NULL
&& msymbol
.minsym
== NULL
)
678 /* If the nearest symbol is too far away, don't print anything symbolic. */
680 /* For when CORE_ADDR is larger than unsigned int, we do math in
681 CORE_ADDR. But when we detect unsigned wraparound in the
682 CORE_ADDR math, we ignore this test and print the offset,
683 because addr+max_symbolic_offset has wrapped through the end
684 of the address space back to the beginning, giving bogus comparison. */
685 if (addr
> name_location
+ max_symbolic_offset
686 && name_location
+ max_symbolic_offset
> name_location
)
689 *offset
= (LONGEST
) addr
- name_location
;
693 if (print_symbol_filename
)
695 struct symtab_and_line sal
;
697 sal
= find_pc_sect_line (addr
, section
, 0);
701 *filename
= symtab_to_filename_for_display (sal
.symtab
);
709 /* Print address ADDR symbolically on STREAM.
710 First print it as a number. Then perhaps print
711 <SYMBOL + OFFSET> after the number. */
714 print_address (struct gdbarch
*gdbarch
,
715 CORE_ADDR addr
, struct ui_file
*stream
)
717 fputs_styled (paddress (gdbarch
, addr
), address_style
.style (), stream
);
718 print_address_symbolic (gdbarch
, addr
, stream
, asm_demangle
, " ");
721 /* Return a prefix for instruction address:
722 "=> " for current instruction, else " ". */
725 pc_prefix (CORE_ADDR addr
)
727 if (has_stack_frames ())
729 struct frame_info
*frame
;
732 frame
= get_selected_frame (NULL
);
733 if (get_frame_pc_if_available (frame
, &pc
) && pc
== addr
)
739 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
740 controls whether to print the symbolic name "raw" or demangled.
741 Return non-zero if anything was printed; zero otherwise. */
744 print_address_demangle (const struct value_print_options
*opts
,
745 struct gdbarch
*gdbarch
, CORE_ADDR addr
,
746 struct ui_file
*stream
, int do_demangle
)
748 if (opts
->addressprint
)
750 fputs_styled (paddress (gdbarch
, addr
), address_style
.style (), stream
);
751 print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, " ");
755 return print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, "");
761 /* Find the address of the instruction that is INST_COUNT instructions before
762 the instruction at ADDR.
763 Since some architectures have variable-length instructions, we can't just
764 simply subtract INST_COUNT * INSN_LEN from ADDR. Instead, we use line
765 number information to locate the nearest known instruction boundary,
766 and disassemble forward from there. If we go out of the symbol range
767 during disassembling, we return the lowest address we've got so far and
768 set the number of instructions read to INST_READ. */
771 find_instruction_backward (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
772 int inst_count
, int *inst_read
)
774 /* The vector PCS is used to store instruction addresses within
776 CORE_ADDR loop_start
, loop_end
, p
;
777 std::vector
<CORE_ADDR
> pcs
;
778 struct symtab_and_line sal
;
781 loop_start
= loop_end
= addr
;
783 /* In each iteration of the outer loop, we get a pc range that ends before
784 LOOP_START, then we count and store every instruction address of the range
785 iterated in the loop.
786 If the number of instructions counted reaches INST_COUNT, return the
787 stored address that is located INST_COUNT instructions back from ADDR.
788 If INST_COUNT is not reached, we subtract the number of counted
789 instructions from INST_COUNT, and go to the next iteration. */
793 sal
= find_pc_sect_line (loop_start
, NULL
, 1);
796 /* We reach here when line info is not available. In this case,
797 we print a message and just exit the loop. The return value
798 is calculated after the loop. */
799 printf_filtered (_("No line number information available "
802 print_address (gdbarch
, loop_start
- 1, gdb_stdout
);
803 printf_filtered ("\n");
807 loop_end
= loop_start
;
810 /* This loop pushes instruction addresses in the range from
811 LOOP_START to LOOP_END. */
812 for (p
= loop_start
; p
< loop_end
;)
815 p
+= gdb_insn_length (gdbarch
, p
);
818 inst_count
-= pcs
.size ();
819 *inst_read
+= pcs
.size ();
821 while (inst_count
> 0);
823 /* After the loop, the vector PCS has instruction addresses of the last
824 source line we processed, and INST_COUNT has a negative value.
825 We return the address at the index of -INST_COUNT in the vector for
827 Let's assume the following instruction addresses and run 'x/-4i 0x400e'.
837 find_instruction_backward is called with INST_COUNT = 4 and expected to
838 return 0x4001. When we reach here, INST_COUNT is set to -1 because
839 it was subtracted by 2 (from Line Y) and 3 (from Line X). The value
840 4001 is located at the index 1 of the last iterated line (= Line X),
841 which is simply calculated by -INST_COUNT.
842 The case when the length of PCS is 0 means that we reached an area for
843 which line info is not available. In such case, we return LOOP_START,
844 which was the lowest instruction address that had line info. */
845 p
= pcs
.size () > 0 ? pcs
[-inst_count
] : loop_start
;
847 /* INST_READ includes all instruction addresses in a pc range. Need to
848 exclude the beginning part up to the address we're returning. That
849 is, exclude {0x4000} in the example above. */
851 *inst_read
+= inst_count
;
856 /* Backward read LEN bytes of target memory from address MEMADDR + LEN,
857 placing the results in GDB's memory from MYADDR + LEN. Returns
858 a count of the bytes actually read. */
861 read_memory_backward (struct gdbarch
*gdbarch
,
862 CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
865 int nread
; /* Number of bytes actually read. */
867 /* First try a complete read. */
868 errcode
= target_read_memory (memaddr
, myaddr
, len
);
876 /* Loop, reading one byte at a time until we get as much as we can. */
879 for (nread
= 0; nread
< len
; ++nread
)
881 errcode
= target_read_memory (--memaddr
, --myaddr
, 1);
884 /* The read was unsuccessful, so exit the loop. */
885 printf_filtered (_("Cannot access memory at address %s\n"),
886 paddress (gdbarch
, memaddr
));
894 /* Returns true if X (which is LEN bytes wide) is the number zero. */
897 integer_is_zero (const gdb_byte
*x
, int len
)
901 while (i
< len
&& x
[i
] == 0)
906 /* Find the start address of a string in which ADDR is included.
907 Basically we search for '\0' and return the next address,
908 but if OPTIONS->PRINT_MAX is smaller than the length of a string,
909 we stop searching and return the address to print characters as many as
910 PRINT_MAX from the string. */
913 find_string_backward (struct gdbarch
*gdbarch
,
914 CORE_ADDR addr
, int count
, int char_size
,
915 const struct value_print_options
*options
,
916 int *strings_counted
)
918 const int chunk_size
= 0x20;
921 int chars_to_read
= chunk_size
;
922 int chars_counted
= 0;
923 int count_original
= count
;
924 CORE_ADDR string_start_addr
= addr
;
926 gdb_assert (char_size
== 1 || char_size
== 2 || char_size
== 4);
927 gdb::byte_vector
buffer (chars_to_read
* char_size
);
928 while (count
> 0 && read_error
== 0)
932 addr
-= chars_to_read
* char_size
;
933 chars_read
= read_memory_backward (gdbarch
, addr
, buffer
.data (),
934 chars_to_read
* char_size
);
935 chars_read
/= char_size
;
936 read_error
= (chars_read
== chars_to_read
) ? 0 : 1;
937 /* Searching for '\0' from the end of buffer in backward direction. */
938 for (i
= 0; i
< chars_read
&& count
> 0 ; ++i
, ++chars_counted
)
940 int offset
= (chars_to_read
- i
- 1) * char_size
;
942 if (integer_is_zero (&buffer
[offset
], char_size
)
943 || chars_counted
== options
->print_max
)
945 /* Found '\0' or reached print_max. As OFFSET is the offset to
946 '\0', we add CHAR_SIZE to return the start address of
949 string_start_addr
= addr
+ offset
+ char_size
;
955 /* Update STRINGS_COUNTED with the actual number of loaded strings. */
956 *strings_counted
= count_original
- count
;
960 /* In error case, STRING_START_ADDR is pointing to the string that
961 was last successfully loaded. Rewind the partially loaded string. */
962 string_start_addr
-= chars_counted
* char_size
;
965 return string_start_addr
;
968 /* Examine data at address ADDR in format FMT.
969 Fetch it from memory and print on gdb_stdout. */
972 do_examine (struct format_data fmt
, struct gdbarch
*gdbarch
, CORE_ADDR addr
)
977 struct type
*val_type
= NULL
;
980 struct value_print_options opts
;
981 int need_to_update_next_address
= 0;
982 CORE_ADDR addr_rewound
= 0;
987 next_gdbarch
= gdbarch
;
990 /* Instruction format implies fetch single bytes
991 regardless of the specified size.
992 The case of strings is handled in decode_format, only explicit
993 size operator are not changed to 'b'. */
999 /* Pick the appropriate size for an address. */
1000 if (gdbarch_ptr_bit (next_gdbarch
) == 64)
1002 else if (gdbarch_ptr_bit (next_gdbarch
) == 32)
1004 else if (gdbarch_ptr_bit (next_gdbarch
) == 16)
1007 /* Bad value for gdbarch_ptr_bit. */
1008 internal_error (__FILE__
, __LINE__
,
1009 _("failed internal consistency check"));
1013 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1014 else if (size
== 'h')
1015 val_type
= builtin_type (next_gdbarch
)->builtin_int16
;
1016 else if (size
== 'w')
1017 val_type
= builtin_type (next_gdbarch
)->builtin_int32
;
1018 else if (size
== 'g')
1019 val_type
= builtin_type (next_gdbarch
)->builtin_int64
;
1023 struct type
*char_type
= NULL
;
1025 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
1026 if type is not found. */
1028 char_type
= builtin_type (next_gdbarch
)->builtin_char16
;
1029 else if (size
== 'w')
1030 char_type
= builtin_type (next_gdbarch
)->builtin_char32
;
1032 val_type
= char_type
;
1035 if (size
!= '\0' && size
!= 'b')
1036 warning (_("Unable to display strings with "
1037 "size '%c', using 'b' instead."), size
);
1039 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1048 if (format
== 's' || format
== 'i')
1051 get_formatted_print_options (&opts
, format
);
1055 /* This is the negative repeat count case.
1056 We rewind the address based on the given repeat count and format,
1057 then examine memory from there in forward direction. */
1062 next_address
= find_instruction_backward (gdbarch
, addr
, count
,
1065 else if (format
== 's')
1067 next_address
= find_string_backward (gdbarch
, addr
, count
,
1068 TYPE_LENGTH (val_type
),
1073 next_address
= addr
- count
* TYPE_LENGTH (val_type
);
1076 /* The following call to print_formatted updates next_address in every
1077 iteration. In backward case, we store the start address here
1078 and update next_address with it before exiting the function. */
1079 addr_rewound
= (format
== 's'
1080 ? next_address
- TYPE_LENGTH (val_type
)
1082 need_to_update_next_address
= 1;
1085 /* Print as many objects as specified in COUNT, at most maxelts per line,
1086 with the address of the next one at the start of each line. */
1092 fputs_filtered (pc_prefix (next_address
), gdb_stdout
);
1093 print_address (next_gdbarch
, next_address
, gdb_stdout
);
1094 printf_filtered (":");
1099 printf_filtered ("\t");
1100 /* Note that print_formatted sets next_address for the next
1102 last_examine_address
= next_address
;
1104 /* The value to be displayed is not fetched greedily.
1105 Instead, to avoid the possibility of a fetched value not
1106 being used, its retrieval is delayed until the print code
1107 uses it. When examining an instruction stream, the
1108 disassembler will perform its own memory fetch using just
1109 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
1110 the disassembler be modified so that LAST_EXAMINE_VALUE
1111 is left with the byte sequence from the last complete
1112 instruction fetched from memory? */
1114 = release_value (value_at_lazy (val_type
, next_address
));
1116 print_formatted (last_examine_value
.get (), size
, &opts
, gdb_stdout
);
1118 /* Display any branch delay slots following the final insn. */
1119 if (format
== 'i' && count
== 1)
1120 count
+= branch_delay_insns
;
1122 printf_filtered ("\n");
1125 if (need_to_update_next_address
)
1126 next_address
= addr_rewound
;
1130 validate_format (struct format_data fmt
, const char *cmdname
)
1133 error (_("Size letters are meaningless in \"%s\" command."), cmdname
);
1135 error (_("Item count other than 1 is meaningless in \"%s\" command."),
1137 if (fmt
.format
== 'i')
1138 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
1139 fmt
.format
, cmdname
);
1142 /* Parse print command format string into *OPTS and update *EXPP.
1143 CMDNAME should name the current command. */
1146 print_command_parse_format (const char **expp
, const char *cmdname
,
1147 value_print_options
*opts
)
1149 const char *exp
= *expp
;
1151 /* opts->raw value might already have been set by 'set print raw-values'
1152 or by using 'print -raw-values'.
1153 So, do not set opts->raw to 0, only set it to 1 if /r is given. */
1154 if (exp
&& *exp
== '/')
1159 fmt
= decode_format (&exp
, last_format
, 0);
1160 validate_format (fmt
, cmdname
);
1161 last_format
= fmt
.format
;
1163 opts
->format
= fmt
.format
;
1164 opts
->raw
= opts
->raw
|| fmt
.raw
;
1174 /* See valprint.h. */
1177 print_value (value
*val
, const value_print_options
&opts
)
1179 int histindex
= record_latest_value (val
);
1181 annotate_value_history_begin (histindex
, value_type (val
));
1183 printf_filtered ("$%d = ", histindex
);
1185 annotate_value_history_value ();
1187 print_formatted (val
, 0, &opts
, gdb_stdout
);
1188 printf_filtered ("\n");
1190 annotate_value_history_end ();
1193 /* Implementation of the "print" and "call" commands. */
1196 print_command_1 (const char *args
, int voidprint
)
1199 value_print_options print_opts
;
1201 get_user_print_options (&print_opts
);
1202 /* Override global settings with explicit options, if any. */
1203 auto group
= make_value_print_options_def_group (&print_opts
);
1204 gdb::option::process_options
1205 (&args
, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER
, group
);
1207 print_command_parse_format (&args
, "print", &print_opts
);
1209 const char *exp
= args
;
1211 if (exp
!= nullptr && *exp
)
1213 expression_up expr
= parse_expression (exp
);
1214 val
= evaluate_expression (expr
.get ());
1217 val
= access_value_history (0);
1219 if (voidprint
|| (val
&& value_type (val
) &&
1220 value_type (val
)->code () != TYPE_CODE_VOID
))
1221 print_value (val
, print_opts
);
1224 /* See valprint.h. */
1227 print_command_completer (struct cmd_list_element
*ignore
,
1228 completion_tracker
&tracker
,
1229 const char *text
, const char * /*word*/)
1231 const auto group
= make_value_print_options_def_group (nullptr);
1232 if (gdb::option::complete_options
1233 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER
, group
))
1236 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
1237 expression_completer (ignore
, tracker
, text
, word
);
1241 print_command (const char *exp
, int from_tty
)
1243 print_command_1 (exp
, 1);
1246 /* Same as print, except it doesn't print void results. */
1248 call_command (const char *exp
, int from_tty
)
1250 print_command_1 (exp
, 0);
1253 /* Implementation of the "output" command. */
1256 output_command (const char *exp
, int from_tty
)
1260 struct format_data fmt
;
1261 struct value_print_options opts
;
1266 if (exp
&& *exp
== '/')
1269 fmt
= decode_format (&exp
, 0, 0);
1270 validate_format (fmt
, "output");
1271 format
= fmt
.format
;
1274 expression_up expr
= parse_expression (exp
);
1276 val
= evaluate_expression (expr
.get ());
1278 annotate_value_begin (value_type (val
));
1280 get_formatted_print_options (&opts
, format
);
1282 print_formatted (val
, fmt
.size
, &opts
, gdb_stdout
);
1284 annotate_value_end ();
1287 gdb_flush (gdb_stdout
);
1291 set_command (const char *exp
, int from_tty
)
1293 expression_up expr
= parse_expression (exp
);
1295 if (expr
->nelts
>= 1)
1296 switch (expr
->elts
[0].opcode
)
1298 case UNOP_PREINCREMENT
:
1299 case UNOP_POSTINCREMENT
:
1300 case UNOP_PREDECREMENT
:
1301 case UNOP_POSTDECREMENT
:
1303 case BINOP_ASSIGN_MODIFY
:
1308 (_("Expression is not an assignment (and might have no effect)"));
1311 evaluate_expression (expr
.get ());
1315 info_symbol_command (const char *arg
, int from_tty
)
1317 struct minimal_symbol
*msymbol
;
1318 struct obj_section
*osect
;
1319 CORE_ADDR addr
, sect_addr
;
1321 unsigned int offset
;
1324 error_no_arg (_("address"));
1326 addr
= parse_and_eval_address (arg
);
1327 for (objfile
*objfile
: current_program_space
->objfiles ())
1328 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
1330 /* Only process each object file once, even if there's a separate
1332 if (objfile
->separate_debug_objfile_backlink
)
1335 sect_addr
= overlay_mapped_address (addr
, osect
);
1337 if (obj_section_addr (osect
) <= sect_addr
1338 && sect_addr
< obj_section_endaddr (osect
)
1340 = lookup_minimal_symbol_by_pc_section (sect_addr
,
1343 const char *obj_name
, *mapped
, *sec_name
, *msym_name
;
1344 const char *loc_string
;
1347 offset
= sect_addr
- MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
);
1348 mapped
= section_is_mapped (osect
) ? _("mapped") : _("unmapped");
1349 sec_name
= osect
->the_bfd_section
->name
;
1350 msym_name
= msymbol
->print_name ();
1352 /* Don't print the offset if it is zero.
1353 We assume there's no need to handle i18n of "sym + offset". */
1354 std::string string_holder
;
1357 string_holder
= string_printf ("%s + %u", msym_name
, offset
);
1358 loc_string
= string_holder
.c_str ();
1361 loc_string
= msym_name
;
1363 gdb_assert (osect
->objfile
&& objfile_name (osect
->objfile
));
1364 obj_name
= objfile_name (osect
->objfile
);
1366 if (current_program_space
->multi_objfile_p ())
1367 if (pc_in_unmapped_range (addr
, osect
))
1368 if (section_is_overlay (osect
))
1369 printf_filtered (_("%s in load address range of "
1370 "%s overlay section %s of %s\n"),
1371 loc_string
, mapped
, sec_name
, obj_name
);
1373 printf_filtered (_("%s in load address range of "
1374 "section %s of %s\n"),
1375 loc_string
, sec_name
, obj_name
);
1377 if (section_is_overlay (osect
))
1378 printf_filtered (_("%s in %s overlay section %s of %s\n"),
1379 loc_string
, mapped
, sec_name
, obj_name
);
1381 printf_filtered (_("%s in section %s of %s\n"),
1382 loc_string
, sec_name
, obj_name
);
1384 if (pc_in_unmapped_range (addr
, osect
))
1385 if (section_is_overlay (osect
))
1386 printf_filtered (_("%s in load address range of %s overlay "
1388 loc_string
, mapped
, sec_name
);
1391 (_("%s in load address range of section %s\n"),
1392 loc_string
, sec_name
);
1394 if (section_is_overlay (osect
))
1395 printf_filtered (_("%s in %s overlay section %s\n"),
1396 loc_string
, mapped
, sec_name
);
1398 printf_filtered (_("%s in section %s\n"),
1399 loc_string
, sec_name
);
1403 printf_filtered (_("No symbol matches %s.\n"), arg
);
1407 info_address_command (const char *exp
, int from_tty
)
1409 struct gdbarch
*gdbarch
;
1412 struct bound_minimal_symbol msymbol
;
1414 struct obj_section
*section
;
1415 CORE_ADDR load_addr
, context_pc
= 0;
1416 struct field_of_this_result is_a_field_of_this
;
1419 error (_("Argument required."));
1421 sym
= lookup_symbol (exp
, get_selected_block (&context_pc
), VAR_DOMAIN
,
1422 &is_a_field_of_this
).symbol
;
1425 if (is_a_field_of_this
.type
!= NULL
)
1427 printf_filtered ("Symbol \"");
1428 fprintf_symbol_filtered (gdb_stdout
, exp
,
1429 current_language
->la_language
, DMGL_ANSI
);
1430 printf_filtered ("\" is a field of the local class variable ");
1431 if (current_language
->la_language
== language_objc
)
1432 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1434 printf_filtered ("`this'\n");
1438 msymbol
= lookup_bound_minimal_symbol (exp
);
1440 if (msymbol
.minsym
!= NULL
)
1442 struct objfile
*objfile
= msymbol
.objfile
;
1444 gdbarch
= objfile
->arch ();
1445 load_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
1447 printf_filtered ("Symbol \"");
1448 fprintf_symbol_filtered (gdb_stdout
, exp
,
1449 current_language
->la_language
, DMGL_ANSI
);
1450 printf_filtered ("\" is at ");
1451 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1453 printf_filtered (" in a file compiled without debugging");
1454 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
1455 if (section_is_overlay (section
))
1457 load_addr
= overlay_unmapped_address (load_addr
, section
);
1458 printf_filtered (",\n -- loaded at ");
1459 fputs_styled (paddress (gdbarch
, load_addr
),
1460 address_style
.style (),
1462 printf_filtered (" in overlay section %s",
1463 section
->the_bfd_section
->name
);
1465 printf_filtered (".\n");
1468 error (_("No symbol \"%s\" in current context."), exp
);
1472 printf_filtered ("Symbol \"");
1473 fprintf_symbol_filtered (gdb_stdout
, sym
->print_name (),
1474 current_language
->la_language
, DMGL_ANSI
);
1475 printf_filtered ("\" is ");
1476 val
= SYMBOL_VALUE (sym
);
1477 if (SYMBOL_OBJFILE_OWNED (sym
))
1478 section
= SYMBOL_OBJ_SECTION (symbol_objfile (sym
), sym
);
1481 gdbarch
= symbol_arch (sym
);
1483 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
1485 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, context_pc
,
1487 printf_filtered (".\n");
1491 switch (SYMBOL_CLASS (sym
))
1494 case LOC_CONST_BYTES
:
1495 printf_filtered ("constant");
1499 printf_filtered ("a label at address ");
1500 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1501 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1503 if (section_is_overlay (section
))
1505 load_addr
= overlay_unmapped_address (load_addr
, section
);
1506 printf_filtered (",\n -- loaded at ");
1507 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1509 printf_filtered (" in overlay section %s",
1510 section
->the_bfd_section
->name
);
1515 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
1518 /* GDBARCH is the architecture associated with the objfile the symbol
1519 is defined in; the target architecture may be different, and may
1520 provide additional registers. However, we do not know the target
1521 architecture at this point. We assume the objfile architecture
1522 will contain all the standard registers that occur in debug info
1524 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1526 if (SYMBOL_IS_ARGUMENT (sym
))
1527 printf_filtered (_("an argument in register %s"),
1528 gdbarch_register_name (gdbarch
, regno
));
1530 printf_filtered (_("a variable in register %s"),
1531 gdbarch_register_name (gdbarch
, regno
));
1535 printf_filtered (_("static storage at address "));
1536 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1537 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1539 if (section_is_overlay (section
))
1541 load_addr
= overlay_unmapped_address (load_addr
, section
);
1542 printf_filtered (_(",\n -- loaded at "));
1543 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1545 printf_filtered (_(" in overlay section %s"),
1546 section
->the_bfd_section
->name
);
1550 case LOC_REGPARM_ADDR
:
1551 /* Note comment at LOC_REGISTER. */
1552 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1553 printf_filtered (_("address of an argument in register %s"),
1554 gdbarch_register_name (gdbarch
, regno
));
1558 printf_filtered (_("an argument at offset %ld"), val
);
1562 printf_filtered (_("a local variable at frame offset %ld"), val
);
1566 printf_filtered (_("a reference argument at offset %ld"), val
);
1570 printf_filtered (_("a typedef"));
1574 printf_filtered (_("a function at address "));
1575 load_addr
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
1576 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1578 if (section_is_overlay (section
))
1580 load_addr
= overlay_unmapped_address (load_addr
, section
);
1581 printf_filtered (_(",\n -- loaded at "));
1582 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1584 printf_filtered (_(" in overlay section %s"),
1585 section
->the_bfd_section
->name
);
1589 case LOC_UNRESOLVED
:
1591 struct bound_minimal_symbol msym
;
1593 msym
= lookup_bound_minimal_symbol (sym
->linkage_name ());
1594 if (msym
.minsym
== NULL
)
1595 printf_filtered ("unresolved");
1598 section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
1601 && (section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
1603 load_addr
= MSYMBOL_VALUE_RAW_ADDRESS (msym
.minsym
);
1604 printf_filtered (_("a thread-local variable at offset %s "
1605 "in the thread-local storage for `%s'"),
1606 paddress (gdbarch
, load_addr
),
1607 objfile_name (section
->objfile
));
1611 load_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
1612 printf_filtered (_("static storage at address "));
1613 fputs_styled (paddress (gdbarch
, load_addr
),
1614 address_style
.style (), gdb_stdout
);
1615 if (section_is_overlay (section
))
1617 load_addr
= overlay_unmapped_address (load_addr
, section
);
1618 printf_filtered (_(",\n -- loaded at "));
1619 fputs_styled (paddress (gdbarch
, load_addr
),
1620 address_style
.style (),
1622 printf_filtered (_(" in overlay section %s"),
1623 section
->the_bfd_section
->name
);
1630 case LOC_OPTIMIZED_OUT
:
1631 printf_filtered (_("optimized out"));
1635 printf_filtered (_("of unknown (botched) type"));
1638 printf_filtered (".\n");
1643 x_command (const char *exp
, int from_tty
)
1645 struct format_data fmt
;
1648 fmt
.format
= last_format
? last_format
: 'x';
1649 fmt
.size
= last_size
;
1653 /* If there is no expression and no format, use the most recent
1655 if (exp
== nullptr && last_count
> 0)
1656 fmt
.count
= last_count
;
1658 if (exp
&& *exp
== '/')
1660 const char *tmp
= exp
+ 1;
1662 fmt
= decode_format (&tmp
, last_format
, last_size
);
1666 last_count
= fmt
.count
;
1668 /* If we have an expression, evaluate it and use it as the address. */
1670 if (exp
!= 0 && *exp
!= 0)
1672 expression_up expr
= parse_expression (exp
);
1673 /* Cause expression not to be there any more if this command is
1674 repeated with Newline. But don't clobber a user-defined
1675 command's definition. */
1677 set_repeat_arguments ("");
1678 val
= evaluate_expression (expr
.get ());
1679 if (TYPE_IS_REFERENCE (value_type (val
)))
1680 val
= coerce_ref (val
);
1681 /* In rvalue contexts, such as this, functions are coerced into
1682 pointers to functions. This makes "x/i main" work. */
1683 if (value_type (val
)->code () == TYPE_CODE_FUNC
1684 && VALUE_LVAL (val
) == lval_memory
)
1685 next_address
= value_address (val
);
1687 next_address
= value_as_address (val
);
1689 next_gdbarch
= expr
->gdbarch
;
1693 error_no_arg (_("starting display address"));
1695 do_examine (fmt
, next_gdbarch
, next_address
);
1697 /* If the examine succeeds, we remember its size and format for next
1698 time. Set last_size to 'b' for strings. */
1699 if (fmt
.format
== 's')
1702 last_size
= fmt
.size
;
1703 last_format
= fmt
.format
;
1705 /* Set a couple of internal variables if appropriate. */
1706 if (last_examine_value
!= nullptr)
1708 /* Make last address examined available to the user as $_. Use
1709 the correct pointer type. */
1710 struct type
*pointer_type
1711 = lookup_pointer_type (value_type (last_examine_value
.get ()));
1712 set_internalvar (lookup_internalvar ("_"),
1713 value_from_pointer (pointer_type
,
1714 last_examine_address
));
1716 /* Make contents of last address examined available to the user
1717 as $__. If the last value has not been fetched from memory
1718 then don't fetch it now; instead mark it by voiding the $__
1720 if (value_lazy (last_examine_value
.get ()))
1721 clear_internalvar (lookup_internalvar ("__"));
1723 set_internalvar (lookup_internalvar ("__"), last_examine_value
.get ());
1728 /* Add an expression to the auto-display chain.
1729 Specify the expression. */
1732 display_command (const char *arg
, int from_tty
)
1734 struct format_data fmt
;
1735 struct display
*newobj
;
1736 const char *exp
= arg
;
1747 fmt
= decode_format (&exp
, 0, 0);
1748 if (fmt
.size
&& fmt
.format
== 0)
1750 if (fmt
.format
== 'i' || fmt
.format
== 's')
1761 innermost_block_tracker tracker
;
1762 expression_up expr
= parse_expression (exp
, &tracker
);
1764 newobj
= new display (exp
, std::move (expr
), fmt
,
1765 current_program_space
, tracker
.block ());
1766 all_displays
.emplace_back (newobj
);
1769 do_one_display (newobj
);
1774 /* Clear out the display_chain. Done when new symtabs are loaded,
1775 since this invalidates the types stored in many expressions. */
1780 all_displays
.clear ();
1783 /* Delete the auto-display DISPLAY. */
1786 delete_display (struct display
*display
)
1788 gdb_assert (display
!= NULL
);
1790 auto iter
= std::find_if (all_displays
.begin (),
1791 all_displays
.end (),
1792 [=] (const std::unique_ptr
<struct display
> &item
)
1794 return item
.get () == display
;
1796 gdb_assert (iter
!= all_displays
.end ());
1797 all_displays
.erase (iter
);
1800 /* Call FUNCTION on each of the displays whose numbers are given in
1801 ARGS. DATA is passed unmodified to FUNCTION. */
1804 map_display_numbers (const char *args
,
1805 gdb::function_view
<void (struct display
*)> function
)
1810 error_no_arg (_("one or more display numbers"));
1812 number_or_range_parser
parser (args
);
1814 while (!parser
.finished ())
1816 const char *p
= parser
.cur_tok ();
1818 num
= parser
.get_number ();
1820 warning (_("bad display number at or near '%s'"), p
);
1823 auto iter
= std::find_if (all_displays
.begin (),
1824 all_displays
.end (),
1825 [=] (const std::unique_ptr
<display
> &item
)
1827 return item
->number
== num
;
1829 if (iter
== all_displays
.end ())
1830 printf_unfiltered (_("No display number %d.\n"), num
);
1832 function (iter
->get ());
1837 /* "undisplay" command. */
1840 undisplay_command (const char *args
, int from_tty
)
1844 if (query (_("Delete all auto-display expressions? ")))
1850 map_display_numbers (args
, delete_display
);
1854 /* Display a single auto-display.
1855 Do nothing if the display cannot be printed in the current context,
1856 or if the display is disabled. */
1859 do_one_display (struct display
*d
)
1861 int within_current_scope
;
1866 /* The expression carries the architecture that was used at parse time.
1867 This is a problem if the expression depends on architecture features
1868 (e.g. register numbers), and the current architecture is now different.
1869 For example, a display statement like "display/i $pc" is expected to
1870 display the PC register of the current architecture, not the arch at
1871 the time the display command was given. Therefore, we re-parse the
1872 expression if the current architecture has changed. */
1873 if (d
->exp
!= NULL
&& d
->exp
->gdbarch
!= get_current_arch ())
1884 innermost_block_tracker tracker
;
1885 d
->exp
= parse_expression (d
->exp_string
.c_str (), &tracker
);
1886 d
->block
= tracker
.block ();
1888 catch (const gdb_exception
&ex
)
1890 /* Can't re-parse the expression. Disable this display item. */
1891 d
->enabled_p
= false;
1892 warning (_("Unable to display \"%s\": %s"),
1893 d
->exp_string
.c_str (), ex
.what ());
1900 if (d
->pspace
== current_program_space
)
1901 within_current_scope
= contained_in (get_selected_block (0), d
->block
,
1904 within_current_scope
= 0;
1907 within_current_scope
= 1;
1908 if (!within_current_scope
)
1911 scoped_restore save_display_number
1912 = make_scoped_restore (¤t_display_number
, d
->number
);
1914 annotate_display_begin ();
1915 printf_filtered ("%d", d
->number
);
1916 annotate_display_number_end ();
1917 printf_filtered (": ");
1921 annotate_display_format ();
1923 printf_filtered ("x/");
1924 if (d
->format
.count
!= 1)
1925 printf_filtered ("%d", d
->format
.count
);
1926 printf_filtered ("%c", d
->format
.format
);
1927 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1928 printf_filtered ("%c", d
->format
.size
);
1929 printf_filtered (" ");
1931 annotate_display_expression ();
1933 puts_filtered (d
->exp_string
.c_str ());
1934 annotate_display_expression_end ();
1936 if (d
->format
.count
!= 1 || d
->format
.format
== 'i')
1937 printf_filtered ("\n");
1939 printf_filtered (" ");
1941 annotate_display_value ();
1948 val
= evaluate_expression (d
->exp
.get ());
1949 addr
= value_as_address (val
);
1950 if (d
->format
.format
== 'i')
1951 addr
= gdbarch_addr_bits_remove (d
->exp
->gdbarch
, addr
);
1952 do_examine (d
->format
, d
->exp
->gdbarch
, addr
);
1954 catch (const gdb_exception_error
&ex
)
1956 fprintf_filtered (gdb_stdout
, _("%p[<error: %s>%p]\n"),
1957 metadata_style
.style ().ptr (), ex
.what (),
1963 struct value_print_options opts
;
1965 annotate_display_format ();
1967 if (d
->format
.format
)
1968 printf_filtered ("/%c ", d
->format
.format
);
1970 annotate_display_expression ();
1972 puts_filtered (d
->exp_string
.c_str ());
1973 annotate_display_expression_end ();
1975 printf_filtered (" = ");
1977 annotate_display_expression ();
1979 get_formatted_print_options (&opts
, d
->format
.format
);
1980 opts
.raw
= d
->format
.raw
;
1986 val
= evaluate_expression (d
->exp
.get ());
1987 print_formatted (val
, d
->format
.size
, &opts
, gdb_stdout
);
1989 catch (const gdb_exception_error
&ex
)
1991 fprintf_styled (gdb_stdout
, metadata_style
.style (),
1992 _("<error: %s>"), ex
.what ());
1995 printf_filtered ("\n");
1998 annotate_display_end ();
2000 gdb_flush (gdb_stdout
);
2003 /* Display all of the values on the auto-display chain which can be
2004 evaluated in the current scope. */
2009 for (auto &d
: all_displays
)
2010 do_one_display (d
.get ());
2013 /* Delete the auto-display which we were in the process of displaying.
2014 This is done when there is an error or a signal. */
2017 disable_display (int num
)
2019 for (auto &d
: all_displays
)
2020 if (d
->number
== num
)
2022 d
->enabled_p
= false;
2025 printf_unfiltered (_("No display number %d.\n"), num
);
2029 disable_current_display (void)
2031 if (current_display_number
>= 0)
2033 disable_display (current_display_number
);
2034 fprintf_unfiltered (gdb_stderr
,
2035 _("Disabling display %d to "
2036 "avoid infinite recursion.\n"),
2037 current_display_number
);
2039 current_display_number
= -1;
2043 info_display_command (const char *ignore
, int from_tty
)
2045 if (all_displays
.empty ())
2046 printf_unfiltered (_("There are no auto-display expressions now.\n"));
2048 printf_filtered (_("Auto-display expressions now in effect:\n\
2049 Num Enb Expression\n"));
2051 for (auto &d
: all_displays
)
2053 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
2055 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
2057 else if (d
->format
.format
)
2058 printf_filtered ("/%c ", d
->format
.format
);
2059 puts_filtered (d
->exp_string
.c_str ());
2060 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
, true))
2061 printf_filtered (_(" (cannot be evaluated in the current context)"));
2062 printf_filtered ("\n");
2066 /* Implementation of both the "disable display" and "enable display"
2067 commands. ENABLE decides what to do. */
2070 enable_disable_display_command (const char *args
, int from_tty
, bool enable
)
2074 for (auto &d
: all_displays
)
2075 d
->enabled_p
= enable
;
2079 map_display_numbers (args
,
2080 [=] (struct display
*d
)
2082 d
->enabled_p
= enable
;
2086 /* The "enable display" command. */
2089 enable_display_command (const char *args
, int from_tty
)
2091 enable_disable_display_command (args
, from_tty
, true);
2094 /* The "disable display" command. */
2097 disable_display_command (const char *args
, int from_tty
)
2099 enable_disable_display_command (args
, from_tty
, false);
2102 /* display_chain items point to blocks and expressions. Some expressions in
2103 turn may point to symbols.
2104 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
2105 obstack_free'd when a shared library is unloaded.
2106 Clear pointers that are about to become dangling.
2107 Both .exp and .block fields will be restored next time we need to display
2108 an item by re-parsing .exp_string field in the new execution context. */
2111 clear_dangling_display_expressions (struct objfile
*objfile
)
2113 struct program_space
*pspace
;
2115 /* With no symbol file we cannot have a block or expression from it. */
2116 if (objfile
== NULL
)
2118 pspace
= objfile
->pspace
;
2119 if (objfile
->separate_debug_objfile_backlink
)
2121 objfile
= objfile
->separate_debug_objfile_backlink
;
2122 gdb_assert (objfile
->pspace
== pspace
);
2125 for (auto &d
: all_displays
)
2127 if (d
->pspace
!= pspace
)
2130 struct objfile
*bl_objf
= nullptr;
2131 if (d
->block
!= nullptr)
2133 bl_objf
= block_objfile (d
->block
);
2134 if (bl_objf
->separate_debug_objfile_backlink
!= nullptr)
2135 bl_objf
= bl_objf
->separate_debug_objfile_backlink
;
2138 if (bl_objf
== objfile
2139 || (d
->exp
!= NULL
&& exp_uses_objfile (d
->exp
.get (), objfile
)))
2148 /* Print the value in stack frame FRAME of a variable specified by a
2149 struct symbol. NAME is the name to print; if NULL then VAR's print
2150 name will be used. STREAM is the ui_file on which to print the
2151 value. INDENT specifies the number of indent levels to print
2152 before printing the variable name.
2154 This function invalidates FRAME. */
2157 print_variable_and_value (const char *name
, struct symbol
*var
,
2158 struct frame_info
*frame
,
2159 struct ui_file
*stream
, int indent
)
2163 name
= var
->print_name ();
2165 fprintf_filtered (stream
, "%s%ps = ", n_spaces (2 * indent
),
2166 styled_string (variable_name_style
.style (), name
));
2171 struct value_print_options opts
;
2173 /* READ_VAR_VALUE needs a block in order to deal with non-local
2174 references (i.e. to handle nested functions). In this context, we
2175 print variables that are local to this frame, so we can avoid passing
2177 val
= read_var_value (var
, NULL
, frame
);
2178 get_user_print_options (&opts
);
2180 common_val_print (val
, stream
, indent
, &opts
, current_language
);
2182 /* common_val_print invalidates FRAME when a pretty printer calls inferior
2186 catch (const gdb_exception_error
&except
)
2188 fprintf_styled (stream
, metadata_style
.style (),
2189 "<error reading variable %s (%s)>", name
,
2193 fprintf_filtered (stream
, "\n");
2196 /* Subroutine of ui_printf to simplify it.
2197 Print VALUE to STREAM using FORMAT.
2198 VALUE is a C-style string either on the target or
2199 in a GDB internal variable. */
2202 printf_c_string (struct ui_file
*stream
, const char *format
,
2203 struct value
*value
)
2205 const gdb_byte
*str
;
2207 if (value_type (value
)->code () != TYPE_CODE_PTR
2208 && VALUE_LVAL (value
) == lval_internalvar
2209 && c_is_string_type_p (value_type (value
)))
2211 size_t len
= TYPE_LENGTH (value_type (value
));
2213 /* Copy the internal var value to TEM_STR and append a terminating null
2214 character. This protects against corrupted C-style strings that lack
2215 the terminating null char. It also allows Ada-style strings (not
2216 null terminated) to be printed without problems. */
2217 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ 1);
2219 memcpy (tem_str
, value_contents (value
), len
);
2225 CORE_ADDR tem
= value_as_address (value
);;
2230 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2231 fprintf_filtered (stream
, format
, "(null)");
2236 /* This is a %s argument. Find the length of the string. */
2239 for (len
= 0;; len
++)
2244 read_memory (tem
+ len
, &c
, 1);
2249 /* Copy the string contents into a string inside GDB. */
2250 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ 1);
2253 read_memory (tem
, tem_str
, len
);
2259 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2260 fprintf_filtered (stream
, format
, (char *) str
);
2264 /* Subroutine of ui_printf to simplify it.
2265 Print VALUE to STREAM using FORMAT.
2266 VALUE is a wide C-style string on the target or
2267 in a GDB internal variable. */
2270 printf_wide_c_string (struct ui_file
*stream
, const char *format
,
2271 struct value
*value
)
2273 const gdb_byte
*str
;
2275 struct gdbarch
*gdbarch
= get_type_arch (value_type (value
));
2276 struct type
*wctype
= lookup_typename (current_language
,
2277 "wchar_t", NULL
, 0);
2278 int wcwidth
= TYPE_LENGTH (wctype
);
2280 if (VALUE_LVAL (value
) == lval_internalvar
2281 && c_is_string_type_p (value_type (value
)))
2283 str
= value_contents (value
);
2284 len
= TYPE_LENGTH (value_type (value
));
2288 CORE_ADDR tem
= value_as_address (value
);
2293 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2294 fprintf_filtered (stream
, format
, "(null)");
2299 /* This is a %s argument. Find the length of the string. */
2300 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2301 gdb_byte
*buf
= (gdb_byte
*) alloca (wcwidth
);
2303 for (len
= 0;; len
+= wcwidth
)
2306 read_memory (tem
+ len
, buf
, wcwidth
);
2307 if (extract_unsigned_integer (buf
, wcwidth
, byte_order
) == 0)
2311 /* Copy the string contents into a string inside GDB. */
2312 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ wcwidth
);
2315 read_memory (tem
, tem_str
, len
);
2316 memset (&tem_str
[len
], 0, wcwidth
);
2320 auto_obstack output
;
2322 convert_between_encodings (target_wide_charset (gdbarch
),
2325 &output
, translit_char
);
2326 obstack_grow_str0 (&output
, "");
2329 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2330 fprintf_filtered (stream
, format
, obstack_base (&output
));
2334 /* Subroutine of ui_printf to simplify it.
2335 Print VALUE, a floating point value, to STREAM using FORMAT. */
2338 printf_floating (struct ui_file
*stream
, const char *format
,
2339 struct value
*value
, enum argclass argclass
)
2341 /* Parameter data. */
2342 struct type
*param_type
= value_type (value
);
2343 struct gdbarch
*gdbarch
= get_type_arch (param_type
);
2345 /* Determine target type corresponding to the format string. */
2346 struct type
*fmt_type
;
2350 fmt_type
= builtin_type (gdbarch
)->builtin_double
;
2352 case long_double_arg
:
2353 fmt_type
= builtin_type (gdbarch
)->builtin_long_double
;
2355 case dec32float_arg
:
2356 fmt_type
= builtin_type (gdbarch
)->builtin_decfloat
;
2358 case dec64float_arg
:
2359 fmt_type
= builtin_type (gdbarch
)->builtin_decdouble
;
2361 case dec128float_arg
:
2362 fmt_type
= builtin_type (gdbarch
)->builtin_declong
;
2365 gdb_assert_not_reached ("unexpected argument class");
2368 /* To match the traditional GDB behavior, the conversion is
2369 done differently depending on the type of the parameter:
2371 - if the parameter has floating-point type, it's value
2372 is converted to the target type;
2374 - otherwise, if the parameter has a type that is of the
2375 same size as a built-in floating-point type, the value
2376 bytes are interpreted as if they were of that type, and
2377 then converted to the target type (this is not done for
2378 decimal floating-point argument classes);
2380 - otherwise, if the source value has an integer value,
2381 it's value is converted to the target type;
2383 - otherwise, an error is raised.
2385 In either case, the result of the conversion is a byte buffer
2386 formatted in the target format for the target type. */
2388 if (fmt_type
->code () == TYPE_CODE_FLT
)
2390 param_type
= float_type_from_length (param_type
);
2391 if (param_type
!= value_type (value
))
2392 value
= value_from_contents (param_type
, value_contents (value
));
2395 value
= value_cast (fmt_type
, value
);
2397 /* Convert the value to a string and print it. */
2399 = target_float_to_string (value_contents (value
), fmt_type
, format
);
2400 fputs_filtered (str
.c_str (), stream
);
2403 /* Subroutine of ui_printf to simplify it.
2404 Print VALUE, a target pointer, to STREAM using FORMAT. */
2407 printf_pointer (struct ui_file
*stream
, const char *format
,
2408 struct value
*value
)
2410 /* We avoid the host's %p because pointers are too
2411 likely to be the wrong size. The only interesting
2412 modifier for %p is a width; extract that, and then
2413 handle %p as glibc would: %#x or a literal "(nil)". */
2417 #ifdef PRINTF_HAS_LONG_LONG
2418 long long val
= value_as_long (value
);
2420 long val
= value_as_long (value
);
2423 fmt
= (char *) alloca (strlen (format
) + 5);
2425 /* Copy up to the leading %. */
2430 int is_percent
= (*p
== '%');
2445 /* Copy any width or flags. Only the "-" flag is valid for pointers
2446 -- see the format_pieces constructor. */
2447 while (*p
== '-' || (*p
>= '0' && *p
< '9'))
2450 gdb_assert (*p
== 'p' && *(p
+ 1) == '\0');
2453 #ifdef PRINTF_HAS_LONG_LONG
2460 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2461 fprintf_filtered (stream
, fmt
, val
);
2469 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2470 fprintf_filtered (stream
, fmt
, "(nil)");
2475 /* printf "printf format string" ARG to STREAM. */
2478 ui_printf (const char *arg
, struct ui_file
*stream
)
2480 const char *s
= arg
;
2481 std::vector
<struct value
*> val_args
;
2484 error_no_arg (_("format-control string and values to print"));
2486 s
= skip_spaces (s
);
2488 /* A format string should follow, enveloped in double quotes. */
2490 error (_("Bad format string, missing '\"'."));
2492 format_pieces
fpieces (&s
);
2495 error (_("Bad format string, non-terminated '\"'."));
2497 s
= skip_spaces (s
);
2499 if (*s
!= ',' && *s
!= 0)
2500 error (_("Invalid argument syntax"));
2504 s
= skip_spaces (s
);
2509 const char *current_substring
;
2512 for (auto &&piece
: fpieces
)
2513 if (piece
.argclass
!= literal_piece
)
2516 /* Now, parse all arguments and evaluate them.
2517 Store the VALUEs in VAL_ARGS. */
2524 val_args
.push_back (parse_to_comma_and_eval (&s1
));
2531 if (val_args
.size () != nargs_wanted
)
2532 error (_("Wrong number of arguments for specified format-string"));
2534 /* Now actually print them. */
2536 for (auto &&piece
: fpieces
)
2538 current_substring
= piece
.string
;
2539 switch (piece
.argclass
)
2542 printf_c_string (stream
, current_substring
, val_args
[i
]);
2544 case wide_string_arg
:
2545 printf_wide_c_string (stream
, current_substring
, val_args
[i
]);
2549 struct gdbarch
*gdbarch
2550 = get_type_arch (value_type (val_args
[i
]));
2551 struct type
*wctype
= lookup_typename (current_language
,
2552 "wchar_t", NULL
, 0);
2553 struct type
*valtype
;
2554 const gdb_byte
*bytes
;
2556 valtype
= value_type (val_args
[i
]);
2557 if (TYPE_LENGTH (valtype
) != TYPE_LENGTH (wctype
)
2558 || valtype
->code () != TYPE_CODE_INT
)
2559 error (_("expected wchar_t argument for %%lc"));
2561 bytes
= value_contents (val_args
[i
]);
2563 auto_obstack output
;
2565 convert_between_encodings (target_wide_charset (gdbarch
),
2567 bytes
, TYPE_LENGTH (valtype
),
2568 TYPE_LENGTH (valtype
),
2569 &output
, translit_char
);
2570 obstack_grow_str0 (&output
, "");
2573 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2574 fprintf_filtered (stream
, current_substring
,
2575 obstack_base (&output
));
2580 #ifdef PRINTF_HAS_LONG_LONG
2582 long long val
= value_as_long (val_args
[i
]);
2585 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2586 fprintf_filtered (stream
, current_substring
, val
);
2591 error (_("long long not supported in printf"));
2595 int val
= value_as_long (val_args
[i
]);
2598 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2599 fprintf_filtered (stream
, current_substring
, val
);
2605 long val
= value_as_long (val_args
[i
]);
2608 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2609 fprintf_filtered (stream
, current_substring
, val
);
2615 size_t val
= value_as_long (val_args
[i
]);
2618 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2619 fprintf_filtered (stream
, current_substring
, val
);
2623 /* Handles floating-point values. */
2625 case long_double_arg
:
2626 case dec32float_arg
:
2627 case dec64float_arg
:
2628 case dec128float_arg
:
2629 printf_floating (stream
, current_substring
, val_args
[i
],
2633 printf_pointer (stream
, current_substring
, val_args
[i
]);
2636 /* Print a portion of the format string that has no
2637 directives. Note that this will not include any
2638 ordinary %-specs, but it might include "%%". That is
2639 why we use printf_filtered and not puts_filtered here.
2640 Also, we pass a dummy argument because some platforms
2641 have modified GCC to include -Wformat-security by
2642 default, which will warn here if there is no
2645 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2646 fprintf_filtered (stream
, current_substring
, 0);
2650 internal_error (__FILE__
, __LINE__
,
2651 _("failed internal consistency check"));
2653 /* Maybe advance to the next argument. */
2654 if (piece
.argclass
!= literal_piece
)
2660 /* Implement the "printf" command. */
2663 printf_command (const char *arg
, int from_tty
)
2665 ui_printf (arg
, gdb_stdout
);
2666 reset_terminal_style (gdb_stdout
);
2668 gdb_stdout
->flush ();
2671 /* Implement the "eval" command. */
2674 eval_command (const char *arg
, int from_tty
)
2678 ui_printf (arg
, &stb
);
2680 std::string expanded
= insert_user_defined_cmd_args (stb
.c_str ());
2682 execute_command (expanded
.c_str (), from_tty
);
2685 void _initialize_printcmd ();
2687 _initialize_printcmd ()
2689 struct cmd_list_element
*c
;
2691 current_display_number
= -1;
2693 gdb::observers::free_objfile
.attach (clear_dangling_display_expressions
);
2695 add_info ("address", info_address_command
,
2696 _("Describe where symbol SYM is stored.\n\
2697 Usage: info address SYM"));
2699 add_info ("symbol", info_symbol_command
, _("\
2700 Describe what symbol is at location ADDR.\n\
2701 Usage: info symbol ADDR\n\
2702 Only for symbols with fixed locations (global or static scope)."));
2704 add_com ("x", class_vars
, x_command
, _("\
2705 Examine memory: x/FMT ADDRESS.\n\
2706 ADDRESS is an expression for the memory address to examine.\n\
2707 FMT is a repeat count followed by a format letter and a size letter.\n\
2708 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2709 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2710 and z(hex, zero padded on the left).\n\
2711 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2712 The specified number of objects of the specified size are printed\n\
2713 according to the format. If a negative number is specified, memory is\n\
2714 examined backward from the address.\n\n\
2715 Defaults for format and size letters are those previously used.\n\
2716 Default count is 1. Default address is following last thing printed\n\
2717 with this command or \"print\"."));
2719 add_info ("display", info_display_command
, _("\
2720 Expressions to display when program stops, with code numbers.\n\
2721 Usage: info display"));
2723 add_cmd ("undisplay", class_vars
, undisplay_command
, _("\
2724 Cancel some expressions to be displayed when program stops.\n\
2725 Usage: undisplay [NUM]...\n\
2726 Arguments are the code numbers of the expressions to stop displaying.\n\
2727 No argument means cancel all automatic-display expressions.\n\
2728 \"delete display\" has the same effect as this command.\n\
2729 Do \"info display\" to see current list of code numbers."),
2732 add_com ("display", class_vars
, display_command
, _("\
2733 Print value of expression EXP each time the program stops.\n\
2734 Usage: display[/FMT] EXP\n\
2735 /FMT may be used before EXP as in the \"print\" command.\n\
2736 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2737 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2738 and examining is done as in the \"x\" command.\n\n\
2739 With no argument, display all currently requested auto-display expressions.\n\
2740 Use \"undisplay\" to cancel display requests previously made."));
2742 add_cmd ("display", class_vars
, enable_display_command
, _("\
2743 Enable some expressions to be displayed when program stops.\n\
2744 Usage: enable display [NUM]...\n\
2745 Arguments are the code numbers of the expressions to resume displaying.\n\
2746 No argument means enable all automatic-display expressions.\n\
2747 Do \"info display\" to see current list of code numbers."), &enablelist
);
2749 add_cmd ("display", class_vars
, disable_display_command
, _("\
2750 Disable some expressions to be displayed when program stops.\n\
2751 Usage: disable display [NUM]...\n\
2752 Arguments are the code numbers of the expressions to stop displaying.\n\
2753 No argument means disable all automatic-display expressions.\n\
2754 Do \"info display\" to see current list of code numbers."), &disablelist
);
2756 add_cmd ("display", class_vars
, undisplay_command
, _("\
2757 Cancel some expressions to be displayed when program stops.\n\
2758 Usage: delete display [NUM]...\n\
2759 Arguments are the code numbers of the expressions to stop displaying.\n\
2760 No argument means cancel all automatic-display expressions.\n\
2761 Do \"info display\" to see current list of code numbers."), &deletelist
);
2763 add_com ("printf", class_vars
, printf_command
, _("\
2764 Formatted printing, like the C \"printf\" function.\n\
2765 Usage: printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
2766 This supports most C printf format specifications, like %s, %d, etc."));
2768 add_com ("output", class_vars
, output_command
, _("\
2769 Like \"print\" but don't put in value history and don't print newline.\n\
2770 Usage: output EXP\n\
2771 This is useful in user-defined commands."));
2773 add_prefix_cmd ("set", class_vars
, set_command
, _("\
2774 Evaluate expression EXP and assign result to variable VAR.\n\
2775 Usage: set VAR = EXP\n\
2776 This uses assignment syntax appropriate for the current language\n\
2777 (VAR = EXP or VAR := EXP for example).\n\
2778 VAR may be a debugger \"convenience\" variable (names starting\n\
2779 with $), a register (a few standard names starting with $), or an actual\n\
2780 variable in the program being debugged. EXP is any valid expression.\n\
2781 Use \"set variable\" for variables with names identical to set subcommands.\n\
2783 With a subcommand, this command modifies parts of the gdb environment.\n\
2784 You can see these environment settings with the \"show\" command."),
2785 &setlist
, "set ", 1, &cmdlist
);
2787 add_com ("assign", class_vars
, set_command
, _("\
2788 Evaluate expression EXP and assign result to variable VAR.\n\
2789 Usage: assign VAR = EXP\n\
2790 This uses assignment syntax appropriate for the current language\n\
2791 (VAR = EXP or VAR := EXP for example).\n\
2792 VAR may be a debugger \"convenience\" variable (names starting\n\
2793 with $), a register (a few standard names starting with $), or an actual\n\
2794 variable in the program being debugged. EXP is any valid expression.\n\
2795 Use \"set variable\" for variables with names identical to set subcommands.\n\
2796 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2797 You can see these environment settings with the \"show\" command."));
2799 /* "call" is the same as "set", but handy for dbx users to call fns. */
2800 c
= add_com ("call", class_vars
, call_command
, _("\
2801 Call a function in the program.\n\
2803 The argument is the function name and arguments, in the notation of the\n\
2804 current working language. The result is printed and saved in the value\n\
2805 history, if it is not void."));
2806 set_cmd_completer_handle_brkchars (c
, print_command_completer
);
2808 add_cmd ("variable", class_vars
, set_command
, _("\
2809 Evaluate expression EXP and assign result to variable VAR.\n\
2810 Usage: set variable VAR = EXP\n\
2811 This uses assignment syntax appropriate for the current language\n\
2812 (VAR = EXP or VAR := EXP for example).\n\
2813 VAR may be a debugger \"convenience\" variable (names starting\n\
2814 with $), a register (a few standard names starting with $), or an actual\n\
2815 variable in the program being debugged. EXP is any valid expression.\n\
2816 This may usually be abbreviated to simply \"set\"."),
2818 add_alias_cmd ("var", "variable", class_vars
, 0, &setlist
);
2820 const auto print_opts
= make_value_print_options_def_group (nullptr);
2822 static const std::string print_help
= gdb::option::build_help (_("\
2823 Print value of expression EXP.\n\
2824 Usage: print [[OPTION]... --] [/FMT] [EXP]\n\
2829 Note: because this command accepts arbitrary expressions, if you\n\
2830 specify any command option, you must use a double dash (\"--\")\n\
2831 to mark the end of option processing. E.g.: \"print -o -- myobj\".\n\
2833 Variables accessible are those of the lexical environment of the selected\n\
2834 stack frame, plus all those whose scope is global or an entire file.\n\
2836 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2837 $$NUM refers to NUM'th value back from the last one.\n\
2838 Names starting with $ refer to registers (with the values they would have\n\
2839 if the program were to return to the stack frame now selected, restoring\n\
2840 all registers saved by frames farther in) or else to debugger\n\
2841 \"convenience\" variables (any such name not a known register).\n\
2842 Use assignment expressions to give values to convenience variables.\n\
2844 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2845 @ is a binary operator for treating consecutive data objects\n\
2846 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2847 element is FOO, whose second element is stored in the space following\n\
2848 where FOO is stored, etc. FOO must be an expression whose value\n\
2849 resides in memory.\n\
2851 EXP may be preceded with /FMT, where FMT is a format letter\n\
2852 but no count or size letter (see \"x\" command)."),
2855 c
= add_com ("print", class_vars
, print_command
, print_help
.c_str ());
2856 set_cmd_completer_handle_brkchars (c
, print_command_completer
);
2857 add_com_alias ("p", "print", class_vars
, 1);
2858 add_com_alias ("inspect", "print", class_vars
, 1);
2860 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class
,
2861 &max_symbolic_offset
, _("\
2862 Set the largest offset that will be printed in <SYMBOL+1234> form."), _("\
2863 Show the largest offset that will be printed in <SYMBOL+1234> form."), _("\
2864 Tell GDB to only display the symbolic form of an address if the\n\
2865 offset between the closest earlier symbol and the address is less than\n\
2866 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
2867 to always print the symbolic form of an address if any symbol precedes\n\
2868 it. Zero is equivalent to \"unlimited\"."),
2870 show_max_symbolic_offset
,
2871 &setprintlist
, &showprintlist
);
2872 add_setshow_boolean_cmd ("symbol-filename", no_class
,
2873 &print_symbol_filename
, _("\
2874 Set printing of source filename and line number with <SYMBOL>."), _("\
2875 Show printing of source filename and line number with <SYMBOL>."), NULL
,
2877 show_print_symbol_filename
,
2878 &setprintlist
, &showprintlist
);
2880 add_com ("eval", no_class
, eval_command
, _("\
2881 Construct a GDB command and then evaluate it.\n\
2882 Usage: eval \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
2883 Convert the arguments to a string as \"printf\" would, but then\n\
2884 treat this string as a command line, and evaluate it."));