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
->is_unsigned ()))
373 if (len
< TYPE_LENGTH (type
) && byte_order
== BFD_ENDIAN_BIG
)
374 valaddr
+= TYPE_LENGTH (type
) - len
;
377 /* Allow LEN == 0, and in this case, don't assume that VALADDR is
379 const gdb_byte zero
= 0;
386 if (size
!= 0 && (options
->format
== 'x' || options
->format
== 't'))
388 /* Truncate to fit. */
405 error (_("Undefined output size \"%c\"."), size
);
407 if (newlen
< len
&& byte_order
== BFD_ENDIAN_BIG
)
408 valaddr
+= len
- newlen
;
412 /* Historically gdb has printed floats by first casting them to a
413 long, and then printing the long. PR cli/16242 suggests changing
414 this to using C-style hex float format.
416 Biased range types and sub-word scalar types must also be handled
417 here; the value is correctly computed by unpack_long. */
418 gdb::byte_vector converted_bytes
;
419 /* Some cases below will unpack the value again. In the biased
420 range case, we want to avoid this, so we store the unpacked value
421 here for possible use later. */
422 gdb::optional
<LONGEST
> val_long
;
423 if ((type
->code () == TYPE_CODE_FLT
424 && (options
->format
== 'o'
425 || options
->format
== 'x'
426 || options
->format
== 't'
427 || options
->format
== 'z'
428 || options
->format
== 'd'
429 || options
->format
== 'u'))
430 || (type
->code () == TYPE_CODE_RANGE
&& type
->bounds ()->bias
!= 0)
431 || type
->bit_size_differs_p ())
433 val_long
.emplace (unpack_long (type
, valaddr
));
434 converted_bytes
.resize (TYPE_LENGTH (type
));
435 store_signed_integer (converted_bytes
.data (), TYPE_LENGTH (type
),
436 byte_order
, *val_long
);
437 valaddr
= converted_bytes
.data ();
440 /* Printing a non-float type as 'f' will interpret the data as if it were
441 of a floating-point type of the same length, if that exists. Otherwise,
442 the data is printed as integer. */
443 char format
= options
->format
;
444 if (format
== 'f' && type
->code () != TYPE_CODE_FLT
)
446 type
= float_type_from_length (type
);
447 if (type
->code () != TYPE_CODE_FLT
)
454 print_octal_chars (stream
, valaddr
, len
, byte_order
);
457 print_decimal_chars (stream
, valaddr
, len
, true, byte_order
);
460 print_decimal_chars (stream
, valaddr
, len
, false, byte_order
);
463 if (type
->code () != TYPE_CODE_FLT
)
465 print_decimal_chars (stream
, valaddr
, len
, !type
->is_unsigned (),
471 print_floating (valaddr
, type
, stream
);
475 print_binary_chars (stream
, valaddr
, len
, byte_order
, size
> 0);
478 print_hex_chars (stream
, valaddr
, len
, byte_order
, size
> 0);
481 print_hex_chars (stream
, valaddr
, len
, byte_order
, true);
485 struct value_print_options opts
= *options
;
487 if (!val_long
.has_value ())
488 val_long
.emplace (unpack_long (type
, valaddr
));
491 if (type
->is_unsigned ())
492 type
= builtin_type (gdbarch
)->builtin_true_unsigned_char
;
494 type
= builtin_type (gdbarch
)->builtin_true_char
;
496 value_print (value_from_longest (type
, *val_long
), stream
, &opts
);
502 if (!val_long
.has_value ())
503 val_long
.emplace (unpack_long (type
, valaddr
));
504 print_address (gdbarch
, *val_long
, stream
);
509 error (_("Undefined output format \"%c\"."), format
);
513 /* Specify default address for `x' command.
514 The `info lines' command uses this. */
517 set_next_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
519 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
521 next_gdbarch
= gdbarch
;
524 /* Make address available to the user as $_. */
525 set_internalvar (lookup_internalvar ("_"),
526 value_from_pointer (ptr_type
, addr
));
529 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
530 after LEADIN. Print nothing if no symbolic name is found nearby.
531 Optionally also print source file and line number, if available.
532 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
533 or to interpret it as a possible C++ name and convert it back to source
534 form. However note that DO_DEMANGLE can be overridden by the specific
535 settings of the demangle and asm_demangle variables. Returns
536 non-zero if anything was printed; zero otherwise. */
539 print_address_symbolic (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
540 struct ui_file
*stream
,
541 int do_demangle
, const char *leadin
)
543 std::string name
, filename
;
548 if (build_address_symbolic (gdbarch
, addr
, do_demangle
, false, &name
,
549 &offset
, &filename
, &line
, &unmapped
))
552 fputs_filtered (leadin
, stream
);
554 fputs_filtered ("<*", stream
);
556 fputs_filtered ("<", stream
);
557 fputs_styled (name
.c_str (), function_name_style
.style (), stream
);
559 fprintf_filtered (stream
, "%+d", offset
);
561 /* Append source filename and line number if desired. Give specific
562 line # of this addr, if we have it; else line # of the nearest symbol. */
563 if (print_symbol_filename
&& !filename
.empty ())
565 fputs_filtered (line
== -1 ? " in " : " at ", stream
);
566 fputs_styled (filename
.c_str (), file_name_style
.style (), stream
);
568 fprintf_filtered (stream
, ":%d", line
);
571 fputs_filtered ("*>", stream
);
573 fputs_filtered (">", stream
);
578 /* See valprint.h. */
581 build_address_symbolic (struct gdbarch
*gdbarch
,
582 CORE_ADDR addr
, /* IN */
583 bool do_demangle
, /* IN */
584 bool prefer_sym_over_minsym
, /* IN */
585 std::string
*name
, /* OUT */
586 int *offset
, /* OUT */
587 std::string
*filename
, /* OUT */
589 int *unmapped
) /* OUT */
591 struct bound_minimal_symbol msymbol
;
592 struct symbol
*symbol
;
593 CORE_ADDR name_location
= 0;
594 struct obj_section
*section
= NULL
;
595 const char *name_temp
= "";
597 /* Let's say it is mapped (not unmapped). */
600 /* Determine if the address is in an overlay, and whether it is
602 if (overlay_debugging
)
604 section
= find_pc_overlay (addr
);
605 if (pc_in_unmapped_range (addr
, section
))
608 addr
= overlay_mapped_address (addr
, section
);
612 /* Try to find the address in both the symbol table and the minsyms.
613 In most cases, we'll prefer to use the symbol instead of the
614 minsym. However, there are cases (see below) where we'll choose
615 to use the minsym instead. */
617 /* This is defective in the sense that it only finds text symbols. So
618 really this is kind of pointless--we should make sure that the
619 minimal symbols have everything we need (by changing that we could
620 save some memory, but for many debug format--ELF/DWARF or
621 anything/stabs--it would be inconvenient to eliminate those minimal
623 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
624 symbol
= find_pc_sect_function (addr
, section
);
628 /* If this is a function (i.e. a code address), strip out any
629 non-address bits. For instance, display a pointer to the
630 first instruction of a Thumb function as <function>; the
631 second instruction will be <function+2>, even though the
632 pointer is <function+3>. This matches the ISA behavior. */
633 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
635 name_location
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (symbol
));
636 if (do_demangle
|| asm_demangle
)
637 name_temp
= symbol
->print_name ();
639 name_temp
= symbol
->linkage_name ();
642 if (msymbol
.minsym
!= NULL
643 && MSYMBOL_HAS_SIZE (msymbol
.minsym
)
644 && MSYMBOL_SIZE (msymbol
.minsym
) == 0
645 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text
646 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text_gnu_ifunc
647 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_file_text
)
648 msymbol
.minsym
= NULL
;
650 if (msymbol
.minsym
!= NULL
)
652 /* Use the minsym if no symbol is found.
654 Additionally, use the minsym instead of a (found) symbol if
655 the following conditions all hold:
656 1) The prefer_sym_over_minsym flag is false.
657 2) The minsym address is identical to that of the address under
659 3) The symbol address is not identical to that of the address
660 under consideration. */
661 if (symbol
== NULL
||
662 (!prefer_sym_over_minsym
663 && BMSYMBOL_VALUE_ADDRESS (msymbol
) == addr
664 && name_location
!= addr
))
666 /* If this is a function (i.e. a code address), strip out any
667 non-address bits. For instance, display a pointer to the
668 first instruction of a Thumb function as <function>; the
669 second instruction will be <function+2>, even though the
670 pointer is <function+3>. This matches the ISA behavior. */
671 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_text
672 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_text_gnu_ifunc
673 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_text
674 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
675 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
678 name_location
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
679 if (do_demangle
|| asm_demangle
)
680 name_temp
= msymbol
.minsym
->print_name ();
682 name_temp
= msymbol
.minsym
->linkage_name ();
685 if (symbol
== NULL
&& msymbol
.minsym
== NULL
)
688 /* If the nearest symbol is too far away, don't print anything symbolic. */
690 /* For when CORE_ADDR is larger than unsigned int, we do math in
691 CORE_ADDR. But when we detect unsigned wraparound in the
692 CORE_ADDR math, we ignore this test and print the offset,
693 because addr+max_symbolic_offset has wrapped through the end
694 of the address space back to the beginning, giving bogus comparison. */
695 if (addr
> name_location
+ max_symbolic_offset
696 && name_location
+ max_symbolic_offset
> name_location
)
699 *offset
= (LONGEST
) addr
- name_location
;
703 if (print_symbol_filename
)
705 struct symtab_and_line sal
;
707 sal
= find_pc_sect_line (addr
, section
, 0);
711 *filename
= symtab_to_filename_for_display (sal
.symtab
);
719 /* Print address ADDR symbolically on STREAM.
720 First print it as a number. Then perhaps print
721 <SYMBOL + OFFSET> after the number. */
724 print_address (struct gdbarch
*gdbarch
,
725 CORE_ADDR addr
, struct ui_file
*stream
)
727 fputs_styled (paddress (gdbarch
, addr
), address_style
.style (), stream
);
728 print_address_symbolic (gdbarch
, addr
, stream
, asm_demangle
, " ");
731 /* Return a prefix for instruction address:
732 "=> " for current instruction, else " ". */
735 pc_prefix (CORE_ADDR addr
)
737 if (has_stack_frames ())
739 struct frame_info
*frame
;
742 frame
= get_selected_frame (NULL
);
743 if (get_frame_pc_if_available (frame
, &pc
) && pc
== addr
)
749 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
750 controls whether to print the symbolic name "raw" or demangled.
751 Return non-zero if anything was printed; zero otherwise. */
754 print_address_demangle (const struct value_print_options
*opts
,
755 struct gdbarch
*gdbarch
, CORE_ADDR addr
,
756 struct ui_file
*stream
, int do_demangle
)
758 if (opts
->addressprint
)
760 fputs_styled (paddress (gdbarch
, addr
), address_style
.style (), stream
);
761 print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, " ");
765 return print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, "");
771 /* Find the address of the instruction that is INST_COUNT instructions before
772 the instruction at ADDR.
773 Since some architectures have variable-length instructions, we can't just
774 simply subtract INST_COUNT * INSN_LEN from ADDR. Instead, we use line
775 number information to locate the nearest known instruction boundary,
776 and disassemble forward from there. If we go out of the symbol range
777 during disassembling, we return the lowest address we've got so far and
778 set the number of instructions read to INST_READ. */
781 find_instruction_backward (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
782 int inst_count
, int *inst_read
)
784 /* The vector PCS is used to store instruction addresses within
786 CORE_ADDR loop_start
, loop_end
, p
;
787 std::vector
<CORE_ADDR
> pcs
;
788 struct symtab_and_line sal
;
791 loop_start
= loop_end
= addr
;
793 /* In each iteration of the outer loop, we get a pc range that ends before
794 LOOP_START, then we count and store every instruction address of the range
795 iterated in the loop.
796 If the number of instructions counted reaches INST_COUNT, return the
797 stored address that is located INST_COUNT instructions back from ADDR.
798 If INST_COUNT is not reached, we subtract the number of counted
799 instructions from INST_COUNT, and go to the next iteration. */
803 sal
= find_pc_sect_line (loop_start
, NULL
, 1);
806 /* We reach here when line info is not available. In this case,
807 we print a message and just exit the loop. The return value
808 is calculated after the loop. */
809 printf_filtered (_("No line number information available "
812 print_address (gdbarch
, loop_start
- 1, gdb_stdout
);
813 printf_filtered ("\n");
817 loop_end
= loop_start
;
820 /* This loop pushes instruction addresses in the range from
821 LOOP_START to LOOP_END. */
822 for (p
= loop_start
; p
< loop_end
;)
825 p
+= gdb_insn_length (gdbarch
, p
);
828 inst_count
-= pcs
.size ();
829 *inst_read
+= pcs
.size ();
831 while (inst_count
> 0);
833 /* After the loop, the vector PCS has instruction addresses of the last
834 source line we processed, and INST_COUNT has a negative value.
835 We return the address at the index of -INST_COUNT in the vector for
837 Let's assume the following instruction addresses and run 'x/-4i 0x400e'.
847 find_instruction_backward is called with INST_COUNT = 4 and expected to
848 return 0x4001. When we reach here, INST_COUNT is set to -1 because
849 it was subtracted by 2 (from Line Y) and 3 (from Line X). The value
850 4001 is located at the index 1 of the last iterated line (= Line X),
851 which is simply calculated by -INST_COUNT.
852 The case when the length of PCS is 0 means that we reached an area for
853 which line info is not available. In such case, we return LOOP_START,
854 which was the lowest instruction address that had line info. */
855 p
= pcs
.size () > 0 ? pcs
[-inst_count
] : loop_start
;
857 /* INST_READ includes all instruction addresses in a pc range. Need to
858 exclude the beginning part up to the address we're returning. That
859 is, exclude {0x4000} in the example above. */
861 *inst_read
+= inst_count
;
866 /* Backward read LEN bytes of target memory from address MEMADDR + LEN,
867 placing the results in GDB's memory from MYADDR + LEN. Returns
868 a count of the bytes actually read. */
871 read_memory_backward (struct gdbarch
*gdbarch
,
872 CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
875 int nread
; /* Number of bytes actually read. */
877 /* First try a complete read. */
878 errcode
= target_read_memory (memaddr
, myaddr
, len
);
886 /* Loop, reading one byte at a time until we get as much as we can. */
889 for (nread
= 0; nread
< len
; ++nread
)
891 errcode
= target_read_memory (--memaddr
, --myaddr
, 1);
894 /* The read was unsuccessful, so exit the loop. */
895 printf_filtered (_("Cannot access memory at address %s\n"),
896 paddress (gdbarch
, memaddr
));
904 /* Returns true if X (which is LEN bytes wide) is the number zero. */
907 integer_is_zero (const gdb_byte
*x
, int len
)
911 while (i
< len
&& x
[i
] == 0)
916 /* Find the start address of a string in which ADDR is included.
917 Basically we search for '\0' and return the next address,
918 but if OPTIONS->PRINT_MAX is smaller than the length of a string,
919 we stop searching and return the address to print characters as many as
920 PRINT_MAX from the string. */
923 find_string_backward (struct gdbarch
*gdbarch
,
924 CORE_ADDR addr
, int count
, int char_size
,
925 const struct value_print_options
*options
,
926 int *strings_counted
)
928 const int chunk_size
= 0x20;
931 int chars_to_read
= chunk_size
;
932 int chars_counted
= 0;
933 int count_original
= count
;
934 CORE_ADDR string_start_addr
= addr
;
936 gdb_assert (char_size
== 1 || char_size
== 2 || char_size
== 4);
937 gdb::byte_vector
buffer (chars_to_read
* char_size
);
938 while (count
> 0 && read_error
== 0)
942 addr
-= chars_to_read
* char_size
;
943 chars_read
= read_memory_backward (gdbarch
, addr
, buffer
.data (),
944 chars_to_read
* char_size
);
945 chars_read
/= char_size
;
946 read_error
= (chars_read
== chars_to_read
) ? 0 : 1;
947 /* Searching for '\0' from the end of buffer in backward direction. */
948 for (i
= 0; i
< chars_read
&& count
> 0 ; ++i
, ++chars_counted
)
950 int offset
= (chars_to_read
- i
- 1) * char_size
;
952 if (integer_is_zero (&buffer
[offset
], char_size
)
953 || chars_counted
== options
->print_max
)
955 /* Found '\0' or reached print_max. As OFFSET is the offset to
956 '\0', we add CHAR_SIZE to return the start address of
959 string_start_addr
= addr
+ offset
+ char_size
;
965 /* Update STRINGS_COUNTED with the actual number of loaded strings. */
966 *strings_counted
= count_original
- count
;
970 /* In error case, STRING_START_ADDR is pointing to the string that
971 was last successfully loaded. Rewind the partially loaded string. */
972 string_start_addr
-= chars_counted
* char_size
;
975 return string_start_addr
;
978 /* Examine data at address ADDR in format FMT.
979 Fetch it from memory and print on gdb_stdout. */
982 do_examine (struct format_data fmt
, struct gdbarch
*gdbarch
, CORE_ADDR addr
)
987 struct type
*val_type
= NULL
;
990 struct value_print_options opts
;
991 int need_to_update_next_address
= 0;
992 CORE_ADDR addr_rewound
= 0;
997 next_gdbarch
= gdbarch
;
1000 /* Instruction format implies fetch single bytes
1001 regardless of the specified size.
1002 The case of strings is handled in decode_format, only explicit
1003 size operator are not changed to 'b'. */
1009 /* Pick the appropriate size for an address. */
1010 if (gdbarch_ptr_bit (next_gdbarch
) == 64)
1012 else if (gdbarch_ptr_bit (next_gdbarch
) == 32)
1014 else if (gdbarch_ptr_bit (next_gdbarch
) == 16)
1017 /* Bad value for gdbarch_ptr_bit. */
1018 internal_error (__FILE__
, __LINE__
,
1019 _("failed internal consistency check"));
1023 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1024 else if (size
== 'h')
1025 val_type
= builtin_type (next_gdbarch
)->builtin_int16
;
1026 else if (size
== 'w')
1027 val_type
= builtin_type (next_gdbarch
)->builtin_int32
;
1028 else if (size
== 'g')
1029 val_type
= builtin_type (next_gdbarch
)->builtin_int64
;
1033 struct type
*char_type
= NULL
;
1035 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
1036 if type is not found. */
1038 char_type
= builtin_type (next_gdbarch
)->builtin_char16
;
1039 else if (size
== 'w')
1040 char_type
= builtin_type (next_gdbarch
)->builtin_char32
;
1042 val_type
= char_type
;
1045 if (size
!= '\0' && size
!= 'b')
1046 warning (_("Unable to display strings with "
1047 "size '%c', using 'b' instead."), size
);
1049 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1058 if (format
== 's' || format
== 'i')
1061 get_formatted_print_options (&opts
, format
);
1065 /* This is the negative repeat count case.
1066 We rewind the address based on the given repeat count and format,
1067 then examine memory from there in forward direction. */
1072 next_address
= find_instruction_backward (gdbarch
, addr
, count
,
1075 else if (format
== 's')
1077 next_address
= find_string_backward (gdbarch
, addr
, count
,
1078 TYPE_LENGTH (val_type
),
1083 next_address
= addr
- count
* TYPE_LENGTH (val_type
);
1086 /* The following call to print_formatted updates next_address in every
1087 iteration. In backward case, we store the start address here
1088 and update next_address with it before exiting the function. */
1089 addr_rewound
= (format
== 's'
1090 ? next_address
- TYPE_LENGTH (val_type
)
1092 need_to_update_next_address
= 1;
1095 /* Print as many objects as specified in COUNT, at most maxelts per line,
1096 with the address of the next one at the start of each line. */
1102 fputs_filtered (pc_prefix (next_address
), gdb_stdout
);
1103 print_address (next_gdbarch
, next_address
, gdb_stdout
);
1104 printf_filtered (":");
1109 printf_filtered ("\t");
1110 /* Note that print_formatted sets next_address for the next
1112 last_examine_address
= next_address
;
1114 /* The value to be displayed is not fetched greedily.
1115 Instead, to avoid the possibility of a fetched value not
1116 being used, its retrieval is delayed until the print code
1117 uses it. When examining an instruction stream, the
1118 disassembler will perform its own memory fetch using just
1119 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
1120 the disassembler be modified so that LAST_EXAMINE_VALUE
1121 is left with the byte sequence from the last complete
1122 instruction fetched from memory? */
1124 = release_value (value_at_lazy (val_type
, next_address
));
1126 print_formatted (last_examine_value
.get (), size
, &opts
, gdb_stdout
);
1128 /* Display any branch delay slots following the final insn. */
1129 if (format
== 'i' && count
== 1)
1130 count
+= branch_delay_insns
;
1132 printf_filtered ("\n");
1135 if (need_to_update_next_address
)
1136 next_address
= addr_rewound
;
1140 validate_format (struct format_data fmt
, const char *cmdname
)
1143 error (_("Size letters are meaningless in \"%s\" command."), cmdname
);
1145 error (_("Item count other than 1 is meaningless in \"%s\" command."),
1147 if (fmt
.format
== 'i')
1148 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
1149 fmt
.format
, cmdname
);
1152 /* Parse print command format string into *OPTS and update *EXPP.
1153 CMDNAME should name the current command. */
1156 print_command_parse_format (const char **expp
, const char *cmdname
,
1157 value_print_options
*opts
)
1159 const char *exp
= *expp
;
1161 /* opts->raw value might already have been set by 'set print raw-values'
1162 or by using 'print -raw-values'.
1163 So, do not set opts->raw to 0, only set it to 1 if /r is given. */
1164 if (exp
&& *exp
== '/')
1169 fmt
= decode_format (&exp
, last_format
, 0);
1170 validate_format (fmt
, cmdname
);
1171 last_format
= fmt
.format
;
1173 opts
->format
= fmt
.format
;
1174 opts
->raw
= opts
->raw
|| fmt
.raw
;
1184 /* See valprint.h. */
1187 print_value (value
*val
, const value_print_options
&opts
)
1189 int histindex
= record_latest_value (val
);
1191 annotate_value_history_begin (histindex
, value_type (val
));
1193 printf_filtered ("$%d = ", histindex
);
1195 annotate_value_history_value ();
1197 print_formatted (val
, 0, &opts
, gdb_stdout
);
1198 printf_filtered ("\n");
1200 annotate_value_history_end ();
1203 /* Implementation of the "print" and "call" commands. */
1206 print_command_1 (const char *args
, int voidprint
)
1209 value_print_options print_opts
;
1211 get_user_print_options (&print_opts
);
1212 /* Override global settings with explicit options, if any. */
1213 auto group
= make_value_print_options_def_group (&print_opts
);
1214 gdb::option::process_options
1215 (&args
, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER
, group
);
1217 print_command_parse_format (&args
, "print", &print_opts
);
1219 const char *exp
= args
;
1221 if (exp
!= nullptr && *exp
)
1223 expression_up expr
= parse_expression (exp
);
1224 val
= evaluate_expression (expr
.get ());
1227 val
= access_value_history (0);
1229 if (voidprint
|| (val
&& value_type (val
) &&
1230 value_type (val
)->code () != TYPE_CODE_VOID
))
1231 print_value (val
, print_opts
);
1234 /* See valprint.h. */
1237 print_command_completer (struct cmd_list_element
*ignore
,
1238 completion_tracker
&tracker
,
1239 const char *text
, const char * /*word*/)
1241 const auto group
= make_value_print_options_def_group (nullptr);
1242 if (gdb::option::complete_options
1243 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER
, group
))
1246 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
1247 expression_completer (ignore
, tracker
, text
, word
);
1251 print_command (const char *exp
, int from_tty
)
1253 print_command_1 (exp
, 1);
1256 /* Same as print, except it doesn't print void results. */
1258 call_command (const char *exp
, int from_tty
)
1260 print_command_1 (exp
, 0);
1263 /* Implementation of the "output" command. */
1266 output_command (const char *exp
, int from_tty
)
1270 struct format_data fmt
;
1271 struct value_print_options opts
;
1276 if (exp
&& *exp
== '/')
1279 fmt
= decode_format (&exp
, 0, 0);
1280 validate_format (fmt
, "output");
1281 format
= fmt
.format
;
1284 expression_up expr
= parse_expression (exp
);
1286 val
= evaluate_expression (expr
.get ());
1288 annotate_value_begin (value_type (val
));
1290 get_formatted_print_options (&opts
, format
);
1292 print_formatted (val
, fmt
.size
, &opts
, gdb_stdout
);
1294 annotate_value_end ();
1297 gdb_flush (gdb_stdout
);
1301 set_command (const char *exp
, int from_tty
)
1303 expression_up expr
= parse_expression (exp
);
1305 if (expr
->nelts
>= 1)
1306 switch (expr
->elts
[0].opcode
)
1308 case UNOP_PREINCREMENT
:
1309 case UNOP_POSTINCREMENT
:
1310 case UNOP_PREDECREMENT
:
1311 case UNOP_POSTDECREMENT
:
1313 case BINOP_ASSIGN_MODIFY
:
1318 (_("Expression is not an assignment (and might have no effect)"));
1321 evaluate_expression (expr
.get ());
1325 info_symbol_command (const char *arg
, int from_tty
)
1327 struct minimal_symbol
*msymbol
;
1328 struct obj_section
*osect
;
1329 CORE_ADDR addr
, sect_addr
;
1331 unsigned int offset
;
1334 error_no_arg (_("address"));
1336 addr
= parse_and_eval_address (arg
);
1337 for (objfile
*objfile
: current_program_space
->objfiles ())
1338 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
1340 /* Only process each object file once, even if there's a separate
1342 if (objfile
->separate_debug_objfile_backlink
)
1345 sect_addr
= overlay_mapped_address (addr
, osect
);
1347 if (obj_section_addr (osect
) <= sect_addr
1348 && sect_addr
< obj_section_endaddr (osect
)
1350 = lookup_minimal_symbol_by_pc_section (sect_addr
,
1353 const char *obj_name
, *mapped
, *sec_name
, *msym_name
;
1354 const char *loc_string
;
1357 offset
= sect_addr
- MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
);
1358 mapped
= section_is_mapped (osect
) ? _("mapped") : _("unmapped");
1359 sec_name
= osect
->the_bfd_section
->name
;
1360 msym_name
= msymbol
->print_name ();
1362 /* Don't print the offset if it is zero.
1363 We assume there's no need to handle i18n of "sym + offset". */
1364 std::string string_holder
;
1367 string_holder
= string_printf ("%s + %u", msym_name
, offset
);
1368 loc_string
= string_holder
.c_str ();
1371 loc_string
= msym_name
;
1373 gdb_assert (osect
->objfile
&& objfile_name (osect
->objfile
));
1374 obj_name
= objfile_name (osect
->objfile
);
1376 if (current_program_space
->multi_objfile_p ())
1377 if (pc_in_unmapped_range (addr
, osect
))
1378 if (section_is_overlay (osect
))
1379 printf_filtered (_("%s in load address range of "
1380 "%s overlay section %s of %s\n"),
1381 loc_string
, mapped
, sec_name
, obj_name
);
1383 printf_filtered (_("%s in load address range of "
1384 "section %s of %s\n"),
1385 loc_string
, sec_name
, obj_name
);
1387 if (section_is_overlay (osect
))
1388 printf_filtered (_("%s in %s overlay section %s of %s\n"),
1389 loc_string
, mapped
, sec_name
, obj_name
);
1391 printf_filtered (_("%s in section %s of %s\n"),
1392 loc_string
, sec_name
, obj_name
);
1394 if (pc_in_unmapped_range (addr
, osect
))
1395 if (section_is_overlay (osect
))
1396 printf_filtered (_("%s in load address range of %s overlay "
1398 loc_string
, mapped
, sec_name
);
1401 (_("%s in load address range of section %s\n"),
1402 loc_string
, sec_name
);
1404 if (section_is_overlay (osect
))
1405 printf_filtered (_("%s in %s overlay section %s\n"),
1406 loc_string
, mapped
, sec_name
);
1408 printf_filtered (_("%s in section %s\n"),
1409 loc_string
, sec_name
);
1413 printf_filtered (_("No symbol matches %s.\n"), arg
);
1417 info_address_command (const char *exp
, int from_tty
)
1419 struct gdbarch
*gdbarch
;
1422 struct bound_minimal_symbol msymbol
;
1424 struct obj_section
*section
;
1425 CORE_ADDR load_addr
, context_pc
= 0;
1426 struct field_of_this_result is_a_field_of_this
;
1429 error (_("Argument required."));
1431 sym
= lookup_symbol (exp
, get_selected_block (&context_pc
), VAR_DOMAIN
,
1432 &is_a_field_of_this
).symbol
;
1435 if (is_a_field_of_this
.type
!= NULL
)
1437 printf_filtered ("Symbol \"");
1438 fprintf_symbol_filtered (gdb_stdout
, exp
,
1439 current_language
->la_language
, DMGL_ANSI
);
1440 printf_filtered ("\" is a field of the local class variable ");
1441 if (current_language
->la_language
== language_objc
)
1442 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1444 printf_filtered ("`this'\n");
1448 msymbol
= lookup_bound_minimal_symbol (exp
);
1450 if (msymbol
.minsym
!= NULL
)
1452 struct objfile
*objfile
= msymbol
.objfile
;
1454 gdbarch
= objfile
->arch ();
1455 load_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
1457 printf_filtered ("Symbol \"");
1458 fprintf_symbol_filtered (gdb_stdout
, exp
,
1459 current_language
->la_language
, DMGL_ANSI
);
1460 printf_filtered ("\" is at ");
1461 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1463 printf_filtered (" in a file compiled without debugging");
1464 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
1465 if (section_is_overlay (section
))
1467 load_addr
= overlay_unmapped_address (load_addr
, section
);
1468 printf_filtered (",\n -- loaded at ");
1469 fputs_styled (paddress (gdbarch
, load_addr
),
1470 address_style
.style (),
1472 printf_filtered (" in overlay section %s",
1473 section
->the_bfd_section
->name
);
1475 printf_filtered (".\n");
1478 error (_("No symbol \"%s\" in current context."), exp
);
1482 printf_filtered ("Symbol \"");
1483 fprintf_symbol_filtered (gdb_stdout
, sym
->print_name (),
1484 current_language
->la_language
, DMGL_ANSI
);
1485 printf_filtered ("\" is ");
1486 val
= SYMBOL_VALUE (sym
);
1487 if (SYMBOL_OBJFILE_OWNED (sym
))
1488 section
= SYMBOL_OBJ_SECTION (symbol_objfile (sym
), sym
);
1491 gdbarch
= symbol_arch (sym
);
1493 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
1495 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, context_pc
,
1497 printf_filtered (".\n");
1501 switch (SYMBOL_CLASS (sym
))
1504 case LOC_CONST_BYTES
:
1505 printf_filtered ("constant");
1509 printf_filtered ("a label at address ");
1510 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1511 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1513 if (section_is_overlay (section
))
1515 load_addr
= overlay_unmapped_address (load_addr
, section
);
1516 printf_filtered (",\n -- loaded at ");
1517 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1519 printf_filtered (" in overlay section %s",
1520 section
->the_bfd_section
->name
);
1525 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
1528 /* GDBARCH is the architecture associated with the objfile the symbol
1529 is defined in; the target architecture may be different, and may
1530 provide additional registers. However, we do not know the target
1531 architecture at this point. We assume the objfile architecture
1532 will contain all the standard registers that occur in debug info
1534 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1536 if (SYMBOL_IS_ARGUMENT (sym
))
1537 printf_filtered (_("an argument in register %s"),
1538 gdbarch_register_name (gdbarch
, regno
));
1540 printf_filtered (_("a variable in register %s"),
1541 gdbarch_register_name (gdbarch
, regno
));
1545 printf_filtered (_("static storage at address "));
1546 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1547 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1549 if (section_is_overlay (section
))
1551 load_addr
= overlay_unmapped_address (load_addr
, section
);
1552 printf_filtered (_(",\n -- loaded at "));
1553 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1555 printf_filtered (_(" in overlay section %s"),
1556 section
->the_bfd_section
->name
);
1560 case LOC_REGPARM_ADDR
:
1561 /* Note comment at LOC_REGISTER. */
1562 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1563 printf_filtered (_("address of an argument in register %s"),
1564 gdbarch_register_name (gdbarch
, regno
));
1568 printf_filtered (_("an argument at offset %ld"), val
);
1572 printf_filtered (_("a local variable at frame offset %ld"), val
);
1576 printf_filtered (_("a reference argument at offset %ld"), val
);
1580 printf_filtered (_("a typedef"));
1584 printf_filtered (_("a function at address "));
1585 load_addr
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
1586 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1588 if (section_is_overlay (section
))
1590 load_addr
= overlay_unmapped_address (load_addr
, section
);
1591 printf_filtered (_(",\n -- loaded at "));
1592 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1594 printf_filtered (_(" in overlay section %s"),
1595 section
->the_bfd_section
->name
);
1599 case LOC_UNRESOLVED
:
1601 struct bound_minimal_symbol msym
;
1603 msym
= lookup_bound_minimal_symbol (sym
->linkage_name ());
1604 if (msym
.minsym
== NULL
)
1605 printf_filtered ("unresolved");
1608 section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
1611 && (section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
1613 load_addr
= MSYMBOL_VALUE_RAW_ADDRESS (msym
.minsym
);
1614 printf_filtered (_("a thread-local variable at offset %s "
1615 "in the thread-local storage for `%s'"),
1616 paddress (gdbarch
, load_addr
),
1617 objfile_name (section
->objfile
));
1621 load_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
1622 printf_filtered (_("static storage at address "));
1623 fputs_styled (paddress (gdbarch
, load_addr
),
1624 address_style
.style (), gdb_stdout
);
1625 if (section_is_overlay (section
))
1627 load_addr
= overlay_unmapped_address (load_addr
, section
);
1628 printf_filtered (_(",\n -- loaded at "));
1629 fputs_styled (paddress (gdbarch
, load_addr
),
1630 address_style
.style (),
1632 printf_filtered (_(" in overlay section %s"),
1633 section
->the_bfd_section
->name
);
1640 case LOC_OPTIMIZED_OUT
:
1641 printf_filtered (_("optimized out"));
1645 printf_filtered (_("of unknown (botched) type"));
1648 printf_filtered (".\n");
1653 x_command (const char *exp
, int from_tty
)
1655 struct format_data fmt
;
1658 fmt
.format
= last_format
? last_format
: 'x';
1659 fmt
.size
= last_size
;
1663 /* If there is no expression and no format, use the most recent
1665 if (exp
== nullptr && last_count
> 0)
1666 fmt
.count
= last_count
;
1668 if (exp
&& *exp
== '/')
1670 const char *tmp
= exp
+ 1;
1672 fmt
= decode_format (&tmp
, last_format
, last_size
);
1676 last_count
= fmt
.count
;
1678 /* If we have an expression, evaluate it and use it as the address. */
1680 if (exp
!= 0 && *exp
!= 0)
1682 expression_up expr
= parse_expression (exp
);
1683 /* Cause expression not to be there any more if this command is
1684 repeated with Newline. But don't clobber a user-defined
1685 command's definition. */
1687 set_repeat_arguments ("");
1688 val
= evaluate_expression (expr
.get ());
1689 if (TYPE_IS_REFERENCE (value_type (val
)))
1690 val
= coerce_ref (val
);
1691 /* In rvalue contexts, such as this, functions are coerced into
1692 pointers to functions. This makes "x/i main" work. */
1693 if (value_type (val
)->code () == TYPE_CODE_FUNC
1694 && VALUE_LVAL (val
) == lval_memory
)
1695 next_address
= value_address (val
);
1697 next_address
= value_as_address (val
);
1699 next_gdbarch
= expr
->gdbarch
;
1703 error_no_arg (_("starting display address"));
1705 do_examine (fmt
, next_gdbarch
, next_address
);
1707 /* If the examine succeeds, we remember its size and format for next
1708 time. Set last_size to 'b' for strings. */
1709 if (fmt
.format
== 's')
1712 last_size
= fmt
.size
;
1713 last_format
= fmt
.format
;
1715 /* Set a couple of internal variables if appropriate. */
1716 if (last_examine_value
!= nullptr)
1718 /* Make last address examined available to the user as $_. Use
1719 the correct pointer type. */
1720 struct type
*pointer_type
1721 = lookup_pointer_type (value_type (last_examine_value
.get ()));
1722 set_internalvar (lookup_internalvar ("_"),
1723 value_from_pointer (pointer_type
,
1724 last_examine_address
));
1726 /* Make contents of last address examined available to the user
1727 as $__. If the last value has not been fetched from memory
1728 then don't fetch it now; instead mark it by voiding the $__
1730 if (value_lazy (last_examine_value
.get ()))
1731 clear_internalvar (lookup_internalvar ("__"));
1733 set_internalvar (lookup_internalvar ("__"), last_examine_value
.get ());
1738 /* Add an expression to the auto-display chain.
1739 Specify the expression. */
1742 display_command (const char *arg
, int from_tty
)
1744 struct format_data fmt
;
1745 struct display
*newobj
;
1746 const char *exp
= arg
;
1757 fmt
= decode_format (&exp
, 0, 0);
1758 if (fmt
.size
&& fmt
.format
== 0)
1760 if (fmt
.format
== 'i' || fmt
.format
== 's')
1771 innermost_block_tracker tracker
;
1772 expression_up expr
= parse_expression (exp
, &tracker
);
1774 newobj
= new display (exp
, std::move (expr
), fmt
,
1775 current_program_space
, tracker
.block ());
1776 all_displays
.emplace_back (newobj
);
1779 do_one_display (newobj
);
1784 /* Clear out the display_chain. Done when new symtabs are loaded,
1785 since this invalidates the types stored in many expressions. */
1790 all_displays
.clear ();
1793 /* Delete the auto-display DISPLAY. */
1796 delete_display (struct display
*display
)
1798 gdb_assert (display
!= NULL
);
1800 auto iter
= std::find_if (all_displays
.begin (),
1801 all_displays
.end (),
1802 [=] (const std::unique_ptr
<struct display
> &item
)
1804 return item
.get () == display
;
1806 gdb_assert (iter
!= all_displays
.end ());
1807 all_displays
.erase (iter
);
1810 /* Call FUNCTION on each of the displays whose numbers are given in
1811 ARGS. DATA is passed unmodified to FUNCTION. */
1814 map_display_numbers (const char *args
,
1815 gdb::function_view
<void (struct display
*)> function
)
1820 error_no_arg (_("one or more display numbers"));
1822 number_or_range_parser
parser (args
);
1824 while (!parser
.finished ())
1826 const char *p
= parser
.cur_tok ();
1828 num
= parser
.get_number ();
1830 warning (_("bad display number at or near '%s'"), p
);
1833 auto iter
= std::find_if (all_displays
.begin (),
1834 all_displays
.end (),
1835 [=] (const std::unique_ptr
<display
> &item
)
1837 return item
->number
== num
;
1839 if (iter
== all_displays
.end ())
1840 printf_unfiltered (_("No display number %d.\n"), num
);
1842 function (iter
->get ());
1847 /* "undisplay" command. */
1850 undisplay_command (const char *args
, int from_tty
)
1854 if (query (_("Delete all auto-display expressions? ")))
1860 map_display_numbers (args
, delete_display
);
1864 /* Display a single auto-display.
1865 Do nothing if the display cannot be printed in the current context,
1866 or if the display is disabled. */
1869 do_one_display (struct display
*d
)
1871 int within_current_scope
;
1876 /* The expression carries the architecture that was used at parse time.
1877 This is a problem if the expression depends on architecture features
1878 (e.g. register numbers), and the current architecture is now different.
1879 For example, a display statement like "display/i $pc" is expected to
1880 display the PC register of the current architecture, not the arch at
1881 the time the display command was given. Therefore, we re-parse the
1882 expression if the current architecture has changed. */
1883 if (d
->exp
!= NULL
&& d
->exp
->gdbarch
!= get_current_arch ())
1894 innermost_block_tracker tracker
;
1895 d
->exp
= parse_expression (d
->exp_string
.c_str (), &tracker
);
1896 d
->block
= tracker
.block ();
1898 catch (const gdb_exception
&ex
)
1900 /* Can't re-parse the expression. Disable this display item. */
1901 d
->enabled_p
= false;
1902 warning (_("Unable to display \"%s\": %s"),
1903 d
->exp_string
.c_str (), ex
.what ());
1910 if (d
->pspace
== current_program_space
)
1911 within_current_scope
= contained_in (get_selected_block (0), d
->block
,
1914 within_current_scope
= 0;
1917 within_current_scope
= 1;
1918 if (!within_current_scope
)
1921 scoped_restore save_display_number
1922 = make_scoped_restore (¤t_display_number
, d
->number
);
1924 annotate_display_begin ();
1925 printf_filtered ("%d", d
->number
);
1926 annotate_display_number_end ();
1927 printf_filtered (": ");
1931 annotate_display_format ();
1933 printf_filtered ("x/");
1934 if (d
->format
.count
!= 1)
1935 printf_filtered ("%d", d
->format
.count
);
1936 printf_filtered ("%c", d
->format
.format
);
1937 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1938 printf_filtered ("%c", d
->format
.size
);
1939 printf_filtered (" ");
1941 annotate_display_expression ();
1943 puts_filtered (d
->exp_string
.c_str ());
1944 annotate_display_expression_end ();
1946 if (d
->format
.count
!= 1 || d
->format
.format
== 'i')
1947 printf_filtered ("\n");
1949 printf_filtered (" ");
1951 annotate_display_value ();
1958 val
= evaluate_expression (d
->exp
.get ());
1959 addr
= value_as_address (val
);
1960 if (d
->format
.format
== 'i')
1961 addr
= gdbarch_addr_bits_remove (d
->exp
->gdbarch
, addr
);
1962 do_examine (d
->format
, d
->exp
->gdbarch
, addr
);
1964 catch (const gdb_exception_error
&ex
)
1966 fprintf_filtered (gdb_stdout
, _("%p[<error: %s>%p]\n"),
1967 metadata_style
.style ().ptr (), ex
.what (),
1973 struct value_print_options opts
;
1975 annotate_display_format ();
1977 if (d
->format
.format
)
1978 printf_filtered ("/%c ", d
->format
.format
);
1980 annotate_display_expression ();
1982 puts_filtered (d
->exp_string
.c_str ());
1983 annotate_display_expression_end ();
1985 printf_filtered (" = ");
1987 annotate_display_expression ();
1989 get_formatted_print_options (&opts
, d
->format
.format
);
1990 opts
.raw
= d
->format
.raw
;
1996 val
= evaluate_expression (d
->exp
.get ());
1997 print_formatted (val
, d
->format
.size
, &opts
, gdb_stdout
);
1999 catch (const gdb_exception_error
&ex
)
2001 fprintf_styled (gdb_stdout
, metadata_style
.style (),
2002 _("<error: %s>"), ex
.what ());
2005 printf_filtered ("\n");
2008 annotate_display_end ();
2010 gdb_flush (gdb_stdout
);
2013 /* Display all of the values on the auto-display chain which can be
2014 evaluated in the current scope. */
2019 for (auto &d
: all_displays
)
2020 do_one_display (d
.get ());
2023 /* Delete the auto-display which we were in the process of displaying.
2024 This is done when there is an error or a signal. */
2027 disable_display (int num
)
2029 for (auto &d
: all_displays
)
2030 if (d
->number
== num
)
2032 d
->enabled_p
= false;
2035 printf_unfiltered (_("No display number %d.\n"), num
);
2039 disable_current_display (void)
2041 if (current_display_number
>= 0)
2043 disable_display (current_display_number
);
2044 fprintf_unfiltered (gdb_stderr
,
2045 _("Disabling display %d to "
2046 "avoid infinite recursion.\n"),
2047 current_display_number
);
2049 current_display_number
= -1;
2053 info_display_command (const char *ignore
, int from_tty
)
2055 if (all_displays
.empty ())
2056 printf_unfiltered (_("There are no auto-display expressions now.\n"));
2058 printf_filtered (_("Auto-display expressions now in effect:\n\
2059 Num Enb Expression\n"));
2061 for (auto &d
: all_displays
)
2063 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
2065 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
2067 else if (d
->format
.format
)
2068 printf_filtered ("/%c ", d
->format
.format
);
2069 puts_filtered (d
->exp_string
.c_str ());
2070 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
, true))
2071 printf_filtered (_(" (cannot be evaluated in the current context)"));
2072 printf_filtered ("\n");
2076 /* Implementation of both the "disable display" and "enable display"
2077 commands. ENABLE decides what to do. */
2080 enable_disable_display_command (const char *args
, int from_tty
, bool enable
)
2084 for (auto &d
: all_displays
)
2085 d
->enabled_p
= enable
;
2089 map_display_numbers (args
,
2090 [=] (struct display
*d
)
2092 d
->enabled_p
= enable
;
2096 /* The "enable display" command. */
2099 enable_display_command (const char *args
, int from_tty
)
2101 enable_disable_display_command (args
, from_tty
, true);
2104 /* The "disable display" command. */
2107 disable_display_command (const char *args
, int from_tty
)
2109 enable_disable_display_command (args
, from_tty
, false);
2112 /* display_chain items point to blocks and expressions. Some expressions in
2113 turn may point to symbols.
2114 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
2115 obstack_free'd when a shared library is unloaded.
2116 Clear pointers that are about to become dangling.
2117 Both .exp and .block fields will be restored next time we need to display
2118 an item by re-parsing .exp_string field in the new execution context. */
2121 clear_dangling_display_expressions (struct objfile
*objfile
)
2123 struct program_space
*pspace
;
2125 /* With no symbol file we cannot have a block or expression from it. */
2126 if (objfile
== NULL
)
2128 pspace
= objfile
->pspace
;
2129 if (objfile
->separate_debug_objfile_backlink
)
2131 objfile
= objfile
->separate_debug_objfile_backlink
;
2132 gdb_assert (objfile
->pspace
== pspace
);
2135 for (auto &d
: all_displays
)
2137 if (d
->pspace
!= pspace
)
2140 struct objfile
*bl_objf
= nullptr;
2141 if (d
->block
!= nullptr)
2143 bl_objf
= block_objfile (d
->block
);
2144 if (bl_objf
->separate_debug_objfile_backlink
!= nullptr)
2145 bl_objf
= bl_objf
->separate_debug_objfile_backlink
;
2148 if (bl_objf
== objfile
2149 || (d
->exp
!= NULL
&& exp_uses_objfile (d
->exp
.get (), objfile
)))
2158 /* Print the value in stack frame FRAME of a variable specified by a
2159 struct symbol. NAME is the name to print; if NULL then VAR's print
2160 name will be used. STREAM is the ui_file on which to print the
2161 value. INDENT specifies the number of indent levels to print
2162 before printing the variable name.
2164 This function invalidates FRAME. */
2167 print_variable_and_value (const char *name
, struct symbol
*var
,
2168 struct frame_info
*frame
,
2169 struct ui_file
*stream
, int indent
)
2173 name
= var
->print_name ();
2175 fprintf_filtered (stream
, "%s%ps = ", n_spaces (2 * indent
),
2176 styled_string (variable_name_style
.style (), name
));
2181 struct value_print_options opts
;
2183 /* READ_VAR_VALUE needs a block in order to deal with non-local
2184 references (i.e. to handle nested functions). In this context, we
2185 print variables that are local to this frame, so we can avoid passing
2187 val
= read_var_value (var
, NULL
, frame
);
2188 get_user_print_options (&opts
);
2190 common_val_print (val
, stream
, indent
, &opts
, current_language
);
2192 /* common_val_print invalidates FRAME when a pretty printer calls inferior
2196 catch (const gdb_exception_error
&except
)
2198 fprintf_styled (stream
, metadata_style
.style (),
2199 "<error reading variable %s (%s)>", name
,
2203 fprintf_filtered (stream
, "\n");
2206 /* Subroutine of ui_printf to simplify it.
2207 Print VALUE to STREAM using FORMAT.
2208 VALUE is a C-style string either on the target or
2209 in a GDB internal variable. */
2212 printf_c_string (struct ui_file
*stream
, const char *format
,
2213 struct value
*value
)
2215 const gdb_byte
*str
;
2217 if (value_type (value
)->code () != TYPE_CODE_PTR
2218 && VALUE_LVAL (value
) == lval_internalvar
2219 && c_is_string_type_p (value_type (value
)))
2221 size_t len
= TYPE_LENGTH (value_type (value
));
2223 /* Copy the internal var value to TEM_STR and append a terminating null
2224 character. This protects against corrupted C-style strings that lack
2225 the terminating null char. It also allows Ada-style strings (not
2226 null terminated) to be printed without problems. */
2227 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ 1);
2229 memcpy (tem_str
, value_contents (value
), len
);
2235 CORE_ADDR tem
= value_as_address (value
);;
2240 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2241 fprintf_filtered (stream
, format
, "(null)");
2246 /* This is a %s argument. Find the length of the string. */
2249 for (len
= 0;; len
++)
2254 read_memory (tem
+ len
, &c
, 1);
2259 /* Copy the string contents into a string inside GDB. */
2260 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ 1);
2263 read_memory (tem
, tem_str
, len
);
2269 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2270 fprintf_filtered (stream
, format
, (char *) str
);
2274 /* Subroutine of ui_printf to simplify it.
2275 Print VALUE to STREAM using FORMAT.
2276 VALUE is a wide C-style string on the target or
2277 in a GDB internal variable. */
2280 printf_wide_c_string (struct ui_file
*stream
, const char *format
,
2281 struct value
*value
)
2283 const gdb_byte
*str
;
2285 struct gdbarch
*gdbarch
= get_type_arch (value_type (value
));
2286 struct type
*wctype
= lookup_typename (current_language
,
2287 "wchar_t", NULL
, 0);
2288 int wcwidth
= TYPE_LENGTH (wctype
);
2290 if (VALUE_LVAL (value
) == lval_internalvar
2291 && c_is_string_type_p (value_type (value
)))
2293 str
= value_contents (value
);
2294 len
= TYPE_LENGTH (value_type (value
));
2298 CORE_ADDR tem
= value_as_address (value
);
2303 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2304 fprintf_filtered (stream
, format
, "(null)");
2309 /* This is a %s argument. Find the length of the string. */
2310 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2311 gdb_byte
*buf
= (gdb_byte
*) alloca (wcwidth
);
2313 for (len
= 0;; len
+= wcwidth
)
2316 read_memory (tem
+ len
, buf
, wcwidth
);
2317 if (extract_unsigned_integer (buf
, wcwidth
, byte_order
) == 0)
2321 /* Copy the string contents into a string inside GDB. */
2322 gdb_byte
*tem_str
= (gdb_byte
*) alloca (len
+ wcwidth
);
2325 read_memory (tem
, tem_str
, len
);
2326 memset (&tem_str
[len
], 0, wcwidth
);
2330 auto_obstack output
;
2332 convert_between_encodings (target_wide_charset (gdbarch
),
2335 &output
, translit_char
);
2336 obstack_grow_str0 (&output
, "");
2339 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2340 fprintf_filtered (stream
, format
, obstack_base (&output
));
2344 /* Subroutine of ui_printf to simplify it.
2345 Print VALUE, a floating point value, to STREAM using FORMAT. */
2348 printf_floating (struct ui_file
*stream
, const char *format
,
2349 struct value
*value
, enum argclass argclass
)
2351 /* Parameter data. */
2352 struct type
*param_type
= value_type (value
);
2353 struct gdbarch
*gdbarch
= get_type_arch (param_type
);
2355 /* Determine target type corresponding to the format string. */
2356 struct type
*fmt_type
;
2360 fmt_type
= builtin_type (gdbarch
)->builtin_double
;
2362 case long_double_arg
:
2363 fmt_type
= builtin_type (gdbarch
)->builtin_long_double
;
2365 case dec32float_arg
:
2366 fmt_type
= builtin_type (gdbarch
)->builtin_decfloat
;
2368 case dec64float_arg
:
2369 fmt_type
= builtin_type (gdbarch
)->builtin_decdouble
;
2371 case dec128float_arg
:
2372 fmt_type
= builtin_type (gdbarch
)->builtin_declong
;
2375 gdb_assert_not_reached ("unexpected argument class");
2378 /* To match the traditional GDB behavior, the conversion is
2379 done differently depending on the type of the parameter:
2381 - if the parameter has floating-point type, it's value
2382 is converted to the target type;
2384 - otherwise, if the parameter has a type that is of the
2385 same size as a built-in floating-point type, the value
2386 bytes are interpreted as if they were of that type, and
2387 then converted to the target type (this is not done for
2388 decimal floating-point argument classes);
2390 - otherwise, if the source value has an integer value,
2391 it's value is converted to the target type;
2393 - otherwise, an error is raised.
2395 In either case, the result of the conversion is a byte buffer
2396 formatted in the target format for the target type. */
2398 if (fmt_type
->code () == TYPE_CODE_FLT
)
2400 param_type
= float_type_from_length (param_type
);
2401 if (param_type
!= value_type (value
))
2402 value
= value_from_contents (param_type
, value_contents (value
));
2405 value
= value_cast (fmt_type
, value
);
2407 /* Convert the value to a string and print it. */
2409 = target_float_to_string (value_contents (value
), fmt_type
, format
);
2410 fputs_filtered (str
.c_str (), stream
);
2413 /* Subroutine of ui_printf to simplify it.
2414 Print VALUE, a target pointer, to STREAM using FORMAT. */
2417 printf_pointer (struct ui_file
*stream
, const char *format
,
2418 struct value
*value
)
2420 /* We avoid the host's %p because pointers are too
2421 likely to be the wrong size. The only interesting
2422 modifier for %p is a width; extract that, and then
2423 handle %p as glibc would: %#x or a literal "(nil)". */
2427 #ifdef PRINTF_HAS_LONG_LONG
2428 long long val
= value_as_long (value
);
2430 long val
= value_as_long (value
);
2433 fmt
= (char *) alloca (strlen (format
) + 5);
2435 /* Copy up to the leading %. */
2440 int is_percent
= (*p
== '%');
2455 /* Copy any width or flags. Only the "-" flag is valid for pointers
2456 -- see the format_pieces constructor. */
2457 while (*p
== '-' || (*p
>= '0' && *p
< '9'))
2460 gdb_assert (*p
== 'p' && *(p
+ 1) == '\0');
2463 #ifdef PRINTF_HAS_LONG_LONG
2470 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2471 fprintf_filtered (stream
, fmt
, val
);
2479 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2480 fprintf_filtered (stream
, fmt
, "(nil)");
2485 /* printf "printf format string" ARG to STREAM. */
2488 ui_printf (const char *arg
, struct ui_file
*stream
)
2490 const char *s
= arg
;
2491 std::vector
<struct value
*> val_args
;
2494 error_no_arg (_("format-control string and values to print"));
2496 s
= skip_spaces (s
);
2498 /* A format string should follow, enveloped in double quotes. */
2500 error (_("Bad format string, missing '\"'."));
2502 format_pieces
fpieces (&s
);
2505 error (_("Bad format string, non-terminated '\"'."));
2507 s
= skip_spaces (s
);
2509 if (*s
!= ',' && *s
!= 0)
2510 error (_("Invalid argument syntax"));
2514 s
= skip_spaces (s
);
2519 const char *current_substring
;
2522 for (auto &&piece
: fpieces
)
2523 if (piece
.argclass
!= literal_piece
)
2526 /* Now, parse all arguments and evaluate them.
2527 Store the VALUEs in VAL_ARGS. */
2534 val_args
.push_back (parse_to_comma_and_eval (&s1
));
2541 if (val_args
.size () != nargs_wanted
)
2542 error (_("Wrong number of arguments for specified format-string"));
2544 /* Now actually print them. */
2546 for (auto &&piece
: fpieces
)
2548 current_substring
= piece
.string
;
2549 switch (piece
.argclass
)
2552 printf_c_string (stream
, current_substring
, val_args
[i
]);
2554 case wide_string_arg
:
2555 printf_wide_c_string (stream
, current_substring
, val_args
[i
]);
2559 struct gdbarch
*gdbarch
2560 = get_type_arch (value_type (val_args
[i
]));
2561 struct type
*wctype
= lookup_typename (current_language
,
2562 "wchar_t", NULL
, 0);
2563 struct type
*valtype
;
2564 const gdb_byte
*bytes
;
2566 valtype
= value_type (val_args
[i
]);
2567 if (TYPE_LENGTH (valtype
) != TYPE_LENGTH (wctype
)
2568 || valtype
->code () != TYPE_CODE_INT
)
2569 error (_("expected wchar_t argument for %%lc"));
2571 bytes
= value_contents (val_args
[i
]);
2573 auto_obstack output
;
2575 convert_between_encodings (target_wide_charset (gdbarch
),
2577 bytes
, TYPE_LENGTH (valtype
),
2578 TYPE_LENGTH (valtype
),
2579 &output
, translit_char
);
2580 obstack_grow_str0 (&output
, "");
2583 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2584 fprintf_filtered (stream
, current_substring
,
2585 obstack_base (&output
));
2590 #ifdef PRINTF_HAS_LONG_LONG
2592 long long val
= value_as_long (val_args
[i
]);
2595 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2596 fprintf_filtered (stream
, current_substring
, val
);
2601 error (_("long long not supported in printf"));
2605 int val
= value_as_long (val_args
[i
]);
2608 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2609 fprintf_filtered (stream
, current_substring
, val
);
2615 long val
= value_as_long (val_args
[i
]);
2618 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2619 fprintf_filtered (stream
, current_substring
, val
);
2625 size_t val
= value_as_long (val_args
[i
]);
2628 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2629 fprintf_filtered (stream
, current_substring
, val
);
2633 /* Handles floating-point values. */
2635 case long_double_arg
:
2636 case dec32float_arg
:
2637 case dec64float_arg
:
2638 case dec128float_arg
:
2639 printf_floating (stream
, current_substring
, val_args
[i
],
2643 printf_pointer (stream
, current_substring
, val_args
[i
]);
2646 /* Print a portion of the format string that has no
2647 directives. Note that this will not include any
2648 ordinary %-specs, but it might include "%%". That is
2649 why we use printf_filtered and not puts_filtered here.
2650 Also, we pass a dummy argument because some platforms
2651 have modified GCC to include -Wformat-security by
2652 default, which will warn here if there is no
2655 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2656 fprintf_filtered (stream
, current_substring
, 0);
2660 internal_error (__FILE__
, __LINE__
,
2661 _("failed internal consistency check"));
2663 /* Maybe advance to the next argument. */
2664 if (piece
.argclass
!= literal_piece
)
2670 /* Implement the "printf" command. */
2673 printf_command (const char *arg
, int from_tty
)
2675 ui_printf (arg
, gdb_stdout
);
2676 reset_terminal_style (gdb_stdout
);
2678 gdb_stdout
->flush ();
2681 /* Implement the "eval" command. */
2684 eval_command (const char *arg
, int from_tty
)
2688 ui_printf (arg
, &stb
);
2690 std::string expanded
= insert_user_defined_cmd_args (stb
.c_str ());
2692 execute_command (expanded
.c_str (), from_tty
);
2695 void _initialize_printcmd ();
2697 _initialize_printcmd ()
2699 struct cmd_list_element
*c
;
2701 current_display_number
= -1;
2703 gdb::observers::free_objfile
.attach (clear_dangling_display_expressions
);
2705 add_info ("address", info_address_command
,
2706 _("Describe where symbol SYM is stored.\n\
2707 Usage: info address SYM"));
2709 add_info ("symbol", info_symbol_command
, _("\
2710 Describe what symbol is at location ADDR.\n\
2711 Usage: info symbol ADDR\n\
2712 Only for symbols with fixed locations (global or static scope)."));
2714 add_com ("x", class_vars
, x_command
, _("\
2715 Examine memory: x/FMT ADDRESS.\n\
2716 ADDRESS is an expression for the memory address to examine.\n\
2717 FMT is a repeat count followed by a format letter and a size letter.\n\
2718 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2719 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2720 and z(hex, zero padded on the left).\n\
2721 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2722 The specified number of objects of the specified size are printed\n\
2723 according to the format. If a negative number is specified, memory is\n\
2724 examined backward from the address.\n\n\
2725 Defaults for format and size letters are those previously used.\n\
2726 Default count is 1. Default address is following last thing printed\n\
2727 with this command or \"print\"."));
2729 add_info ("display", info_display_command
, _("\
2730 Expressions to display when program stops, with code numbers.\n\
2731 Usage: info display"));
2733 add_cmd ("undisplay", class_vars
, undisplay_command
, _("\
2734 Cancel some expressions to be displayed when program stops.\n\
2735 Usage: undisplay [NUM]...\n\
2736 Arguments are the code numbers of the expressions to stop displaying.\n\
2737 No argument means cancel all automatic-display expressions.\n\
2738 \"delete display\" has the same effect as this command.\n\
2739 Do \"info display\" to see current list of code numbers."),
2742 add_com ("display", class_vars
, display_command
, _("\
2743 Print value of expression EXP each time the program stops.\n\
2744 Usage: display[/FMT] EXP\n\
2745 /FMT may be used before EXP as in the \"print\" command.\n\
2746 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2747 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2748 and examining is done as in the \"x\" command.\n\n\
2749 With no argument, display all currently requested auto-display expressions.\n\
2750 Use \"undisplay\" to cancel display requests previously made."));
2752 add_cmd ("display", class_vars
, enable_display_command
, _("\
2753 Enable some expressions to be displayed when program stops.\n\
2754 Usage: enable display [NUM]...\n\
2755 Arguments are the code numbers of the expressions to resume displaying.\n\
2756 No argument means enable all automatic-display expressions.\n\
2757 Do \"info display\" to see current list of code numbers."), &enablelist
);
2759 add_cmd ("display", class_vars
, disable_display_command
, _("\
2760 Disable some expressions to be displayed when program stops.\n\
2761 Usage: disable display [NUM]...\n\
2762 Arguments are the code numbers of the expressions to stop displaying.\n\
2763 No argument means disable all automatic-display expressions.\n\
2764 Do \"info display\" to see current list of code numbers."), &disablelist
);
2766 add_cmd ("display", class_vars
, undisplay_command
, _("\
2767 Cancel some expressions to be displayed when program stops.\n\
2768 Usage: delete display [NUM]...\n\
2769 Arguments are the code numbers of the expressions to stop displaying.\n\
2770 No argument means cancel all automatic-display expressions.\n\
2771 Do \"info display\" to see current list of code numbers."), &deletelist
);
2773 add_com ("printf", class_vars
, printf_command
, _("\
2774 Formatted printing, like the C \"printf\" function.\n\
2775 Usage: printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
2776 This supports most C printf format specifications, like %s, %d, etc."));
2778 add_com ("output", class_vars
, output_command
, _("\
2779 Like \"print\" but don't put in value history and don't print newline.\n\
2780 Usage: output EXP\n\
2781 This is useful in user-defined commands."));
2783 add_prefix_cmd ("set", class_vars
, set_command
, _("\
2784 Evaluate expression EXP and assign result to variable VAR.\n\
2785 Usage: set VAR = EXP\n\
2786 This uses assignment syntax appropriate for the current language\n\
2787 (VAR = EXP or VAR := EXP for example).\n\
2788 VAR may be a debugger \"convenience\" variable (names starting\n\
2789 with $), a register (a few standard names starting with $), or an actual\n\
2790 variable in the program being debugged. EXP is any valid expression.\n\
2791 Use \"set variable\" for variables with names identical to set subcommands.\n\
2793 With a subcommand, this command modifies parts of the gdb environment.\n\
2794 You can see these environment settings with the \"show\" command."),
2795 &setlist
, "set ", 1, &cmdlist
);
2797 add_com ("assign", class_vars
, set_command
, _("\
2798 Evaluate expression EXP and assign result to variable VAR.\n\
2799 Usage: assign VAR = EXP\n\
2800 This uses assignment syntax appropriate for the current language\n\
2801 (VAR = EXP or VAR := EXP for example).\n\
2802 VAR may be a debugger \"convenience\" variable (names starting\n\
2803 with $), a register (a few standard names starting with $), or an actual\n\
2804 variable in the program being debugged. EXP is any valid expression.\n\
2805 Use \"set variable\" for variables with names identical to set subcommands.\n\
2806 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2807 You can see these environment settings with the \"show\" command."));
2809 /* "call" is the same as "set", but handy for dbx users to call fns. */
2810 c
= add_com ("call", class_vars
, call_command
, _("\
2811 Call a function in the program.\n\
2813 The argument is the function name and arguments, in the notation of the\n\
2814 current working language. The result is printed and saved in the value\n\
2815 history, if it is not void."));
2816 set_cmd_completer_handle_brkchars (c
, print_command_completer
);
2818 add_cmd ("variable", class_vars
, set_command
, _("\
2819 Evaluate expression EXP and assign result to variable VAR.\n\
2820 Usage: set variable VAR = EXP\n\
2821 This uses assignment syntax appropriate for the current language\n\
2822 (VAR = EXP or VAR := EXP for example).\n\
2823 VAR may be a debugger \"convenience\" variable (names starting\n\
2824 with $), a register (a few standard names starting with $), or an actual\n\
2825 variable in the program being debugged. EXP is any valid expression.\n\
2826 This may usually be abbreviated to simply \"set\"."),
2828 add_alias_cmd ("var", "variable", class_vars
, 0, &setlist
);
2830 const auto print_opts
= make_value_print_options_def_group (nullptr);
2832 static const std::string print_help
= gdb::option::build_help (_("\
2833 Print value of expression EXP.\n\
2834 Usage: print [[OPTION]... --] [/FMT] [EXP]\n\
2839 Note: because this command accepts arbitrary expressions, if you\n\
2840 specify any command option, you must use a double dash (\"--\")\n\
2841 to mark the end of option processing. E.g.: \"print -o -- myobj\".\n\
2843 Variables accessible are those of the lexical environment of the selected\n\
2844 stack frame, plus all those whose scope is global or an entire file.\n\
2846 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2847 $$NUM refers to NUM'th value back from the last one.\n\
2848 Names starting with $ refer to registers (with the values they would have\n\
2849 if the program were to return to the stack frame now selected, restoring\n\
2850 all registers saved by frames farther in) or else to debugger\n\
2851 \"convenience\" variables (any such name not a known register).\n\
2852 Use assignment expressions to give values to convenience variables.\n\
2854 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2855 @ is a binary operator for treating consecutive data objects\n\
2856 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2857 element is FOO, whose second element is stored in the space following\n\
2858 where FOO is stored, etc. FOO must be an expression whose value\n\
2859 resides in memory.\n\
2861 EXP may be preceded with /FMT, where FMT is a format letter\n\
2862 but no count or size letter (see \"x\" command)."),
2865 c
= add_com ("print", class_vars
, print_command
, print_help
.c_str ());
2866 set_cmd_completer_handle_brkchars (c
, print_command_completer
);
2867 add_com_alias ("p", "print", class_vars
, 1);
2868 add_com_alias ("inspect", "print", class_vars
, 1);
2870 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class
,
2871 &max_symbolic_offset
, _("\
2872 Set the largest offset that will be printed in <SYMBOL+1234> form."), _("\
2873 Show the largest offset that will be printed in <SYMBOL+1234> form."), _("\
2874 Tell GDB to only display the symbolic form of an address if the\n\
2875 offset between the closest earlier symbol and the address is less than\n\
2876 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
2877 to always print the symbolic form of an address if any symbol precedes\n\
2878 it. Zero is equivalent to \"unlimited\"."),
2880 show_max_symbolic_offset
,
2881 &setprintlist
, &showprintlist
);
2882 add_setshow_boolean_cmd ("symbol-filename", no_class
,
2883 &print_symbol_filename
, _("\
2884 Set printing of source filename and line number with <SYMBOL>."), _("\
2885 Show printing of source filename and line number with <SYMBOL>."), NULL
,
2887 show_print_symbol_filename
,
2888 &setprintlist
, &showprintlist
);
2890 add_com ("eval", no_class
, eval_command
, _("\
2891 Construct a GDB command and then evaluate it.\n\
2892 Usage: eval \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
2893 Convert the arguments to a string as \"printf\" would, but then\n\
2894 treat this string as a command line, and evaluate it."));