1 /* Print values for GNU debugger GDB.
3 Copyright (C) 1986-2023 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"
38 #include "completer.h"
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"
56 #include "gdbsupport/gdb-safe-ctype.h"
57 #include "gdbsupport/rsp-low.h"
60 /* Chain containing all defined memory-tag subcommands. */
62 static struct cmd_list_element
*memory_tag_list
;
64 /* Last specified output format. */
66 static char last_format
= 0;
68 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
70 static char last_size
= 'w';
72 /* Last specified count for the 'x' command. */
74 static int last_count
;
76 /* Last specified tag-printing option. */
78 static bool last_print_tags
= false;
80 /* Default address to examine next, and associated architecture. */
82 static struct gdbarch
*next_gdbarch
;
83 static CORE_ADDR next_address
;
85 /* Number of delay instructions following current disassembled insn. */
87 static int branch_delay_insns
;
89 /* Last address examined. */
91 static CORE_ADDR last_examine_address
;
93 /* Contents of last address examined.
94 This is not valid past the end of the `x' command! */
96 static value_ref_ptr last_examine_value
;
98 /* Largest offset between a symbolic value and an address, that will be
99 printed as `0x1234 <symbol+offset>'. */
101 static unsigned int max_symbolic_offset
= UINT_MAX
;
103 show_max_symbolic_offset (struct ui_file
*file
, int from_tty
,
104 struct cmd_list_element
*c
, const char *value
)
107 _("The largest offset that will be "
108 "printed in <symbol+1234> form is %s.\n"),
112 /* Append the source filename and linenumber of the symbol when
113 printing a symbolic value as `<symbol at filename:linenum>' if set. */
114 static bool print_symbol_filename
= false;
116 show_print_symbol_filename (struct ui_file
*file
, int from_tty
,
117 struct cmd_list_element
*c
, const char *value
)
119 gdb_printf (file
, _("Printing of source filename and "
120 "line number with <symbol> is %s.\n"),
124 /* Number of auto-display expression currently being displayed.
125 So that we can disable it if we get a signal within it.
126 -1 when not doing one. */
128 static int current_display_number
;
130 /* Last allocated display number. */
132 static int display_number
;
136 display (const char *exp_string_
, expression_up
&&exp_
,
137 const struct format_data
&format_
, struct program_space
*pspace_
,
138 const struct block
*block_
)
139 : exp_string (exp_string_
),
140 exp (std::move (exp_
)),
141 number (++display_number
),
149 /* The expression as the user typed it. */
150 std::string exp_string
;
152 /* Expression to be evaluated and displayed. */
155 /* Item number of this auto-display item. */
158 /* Display format specified. */
159 struct format_data format
;
161 /* Program space associated with `block'. */
162 struct program_space
*pspace
;
164 /* Innermost block required by this expression when evaluated. */
165 const struct block
*block
;
167 /* Status of this display (enabled or disabled). */
171 /* Expressions whose values should be displayed automatically each
172 time the program stops. */
174 static std::vector
<std::unique_ptr
<struct display
>> all_displays
;
176 /* Prototypes for local functions. */
178 static void do_one_display (struct display
*);
181 /* Decode a format specification. *STRING_PTR should point to it.
182 OFORMAT and OSIZE are used as defaults for the format and size
183 if none are given in the format specification.
184 If OSIZE is zero, then the size field of the returned value
185 should be set only if a size is explicitly specified by the
187 The structure returned describes all the data
188 found in the specification. In addition, *STRING_PTR is advanced
189 past the specification and past all whitespace following it. */
191 static struct format_data
192 decode_format (const char **string_ptr
, int oformat
, int osize
)
194 struct format_data val
;
195 const char *p
= *string_ptr
;
201 val
.print_tags
= false;
208 if (*p
>= '0' && *p
<= '9')
209 val
.count
*= atoi (p
);
210 while (*p
>= '0' && *p
<= '9')
213 /* Now process size or format letters that follow. */
217 if (*p
== 'b' || *p
== 'h' || *p
== 'w' || *p
== 'g')
226 val
.print_tags
= true;
229 else if (*p
>= 'a' && *p
<= 'z')
235 *string_ptr
= skip_spaces (p
);
237 /* Set defaults for format and size if not specified. */
238 if (val
.format
== '?')
242 /* Neither has been specified. */
243 val
.format
= oformat
;
247 /* If a size is specified, any format makes a reasonable
248 default except 'i'. */
249 val
.format
= oformat
== 'i' ? 'x' : oformat
;
251 else if (val
.size
== '?')
255 /* Pick the appropriate size for an address. This is deferred
256 until do_examine when we know the actual architecture to use.
257 A special size value of 'a' is used to indicate this case. */
258 val
.size
= osize
? 'a' : osize
;
261 /* Floating point has to be word or giantword. */
262 if (osize
== 'w' || osize
== 'g')
265 /* Default it to giantword if the last used size is not
267 val
.size
= osize
? 'g' : osize
;
270 /* Characters default to one byte. */
271 val
.size
= osize
? 'b' : osize
;
274 /* Display strings with byte size chars unless explicitly
280 /* The default is the size most recently specified. */
287 /* Print value VAL on stream according to OPTIONS.
288 Do not end with a newline.
289 SIZE is the letter for the size of datum being printed.
290 This is used to pad hex numbers so they line up. SIZE is 0
291 for print / output and set for examine. */
294 print_formatted (struct value
*val
, int size
,
295 const struct value_print_options
*options
,
296 struct ui_file
*stream
)
298 struct type
*type
= check_typedef (val
->type ());
299 int len
= type
->length ();
301 if (val
->lval () == lval_memory
)
302 next_address
= val
->address () + len
;
306 switch (options
->format
)
310 struct type
*elttype
= val
->type ();
312 next_address
= (val
->address ()
313 + val_print_string (elttype
, NULL
,
315 stream
, options
) * len
);
320 /* We often wrap here if there are long symbolic names. */
321 stream
->wrap_here (4);
322 next_address
= (val
->address ()
323 + gdb_print_insn (type
->arch (),
324 val
->address (), stream
,
325 &branch_delay_insns
));
330 if (options
->format
== 0 || options
->format
== 's'
331 || type
->code () == TYPE_CODE_VOID
332 || type
->code () == TYPE_CODE_REF
333 || type
->code () == TYPE_CODE_ARRAY
334 || type
->code () == TYPE_CODE_STRING
335 || type
->code () == TYPE_CODE_STRUCT
336 || type
->code () == TYPE_CODE_UNION
337 || type
->code () == TYPE_CODE_NAMESPACE
)
338 value_print (val
, stream
, options
);
340 /* User specified format, so don't look to the type to tell us
342 value_print_scalar_formatted (val
, options
, size
, stream
);
345 /* Return builtin floating point type of same length as TYPE.
346 If no such type is found, return TYPE itself. */
348 float_type_from_length (struct type
*type
)
350 struct gdbarch
*gdbarch
= type
->arch ();
351 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
353 if (type
->length () == builtin
->builtin_half
->length ())
354 type
= builtin
->builtin_half
;
355 else if (type
->length () == builtin
->builtin_float
->length ())
356 type
= builtin
->builtin_float
;
357 else if (type
->length () == builtin
->builtin_double
->length ())
358 type
= builtin
->builtin_double
;
359 else if (type
->length () == builtin
->builtin_long_double
->length ())
360 type
= builtin
->builtin_long_double
;
365 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
366 according to OPTIONS and SIZE on STREAM. Formats s and i are not
367 supported at this level. */
370 print_scalar_formatted (const gdb_byte
*valaddr
, struct type
*type
,
371 const struct value_print_options
*options
,
372 int size
, struct ui_file
*stream
)
374 struct gdbarch
*gdbarch
= type
->arch ();
375 unsigned int len
= type
->length ();
376 enum bfd_endian byte_order
= type_byte_order (type
);
378 /* String printing should go through val_print_scalar_formatted. */
379 gdb_assert (options
->format
!= 's');
381 /* If the value is a pointer, and pointers and addresses are not the
382 same, then at this point, the value's length (in target bytes) is
383 gdbarch_addr_bit/TARGET_CHAR_BIT, not type->length (). */
384 if (type
->code () == TYPE_CODE_PTR
)
385 len
= gdbarch_addr_bit (gdbarch
) / TARGET_CHAR_BIT
;
387 /* If we are printing it as unsigned, truncate it in case it is actually
388 a negative signed value (e.g. "print/u (short)-1" should print 65535
389 (if shorts are 16 bits) instead of 4294967295). */
390 if (options
->format
!= 'c'
391 && (options
->format
!= 'd' || type
->is_unsigned ()))
393 if (len
< type
->length () && byte_order
== BFD_ENDIAN_BIG
)
394 valaddr
+= type
->length () - len
;
397 /* Allow LEN == 0, and in this case, don't assume that VALADDR is
399 const gdb_byte zero
= 0;
406 if (size
!= 0 && (options
->format
== 'x' || options
->format
== 't'))
408 /* Truncate to fit. */
425 error (_("Undefined output size \"%c\"."), size
);
427 if (newlen
< len
&& byte_order
== BFD_ENDIAN_BIG
)
428 valaddr
+= len
- newlen
;
432 /* Biased range types and sub-word scalar types must be handled
433 here; the value is correctly computed by unpack_long. */
434 gdb::byte_vector converted_bytes
;
435 /* Some cases below will unpack the value again. In the biased
436 range case, we want to avoid this, so we store the unpacked value
437 here for possible use later. */
438 gdb::optional
<LONGEST
> val_long
;
439 if ((is_fixed_point_type (type
)
440 && (options
->format
== 'o'
441 || options
->format
== 'x'
442 || options
->format
== 't'
443 || options
->format
== 'z'
444 || options
->format
== 'd'
445 || options
->format
== 'u'))
446 || (type
->code () == TYPE_CODE_RANGE
&& type
->bounds ()->bias
!= 0)
447 || type
->bit_size_differs_p ())
449 val_long
.emplace (unpack_long (type
, valaddr
));
450 converted_bytes
.resize (type
->length ());
451 store_signed_integer (converted_bytes
.data (), type
->length (),
452 byte_order
, *val_long
);
453 valaddr
= converted_bytes
.data ();
456 /* Printing a non-float type as 'f' will interpret the data as if it were
457 of a floating-point type of the same length, if that exists. Otherwise,
458 the data is printed as integer. */
459 char format
= options
->format
;
460 if (format
== 'f' && type
->code () != TYPE_CODE_FLT
)
462 type
= float_type_from_length (type
);
463 if (type
->code () != TYPE_CODE_FLT
)
470 print_octal_chars (stream
, valaddr
, len
, byte_order
);
473 print_decimal_chars (stream
, valaddr
, len
, true, byte_order
);
476 print_decimal_chars (stream
, valaddr
, len
, false, byte_order
);
479 if (type
->code () != TYPE_CODE_FLT
)
481 print_decimal_chars (stream
, valaddr
, len
, !type
->is_unsigned (),
487 print_floating (valaddr
, type
, stream
);
491 print_binary_chars (stream
, valaddr
, len
, byte_order
, size
> 0, options
);
494 print_hex_chars (stream
, valaddr
, len
, byte_order
, size
> 0);
497 print_hex_chars (stream
, valaddr
, len
, byte_order
, true);
501 struct value_print_options opts
= *options
;
503 if (!val_long
.has_value ())
504 val_long
.emplace (unpack_long (type
, valaddr
));
507 if (type
->is_unsigned ())
508 type
= builtin_type (gdbarch
)->builtin_true_unsigned_char
;
510 type
= builtin_type (gdbarch
)->builtin_true_char
;
512 value_print (value_from_longest (type
, *val_long
), stream
, &opts
);
518 if (!val_long
.has_value ())
519 val_long
.emplace (unpack_long (type
, valaddr
));
520 print_address (gdbarch
, *val_long
, stream
);
525 error (_("Undefined output format \"%c\"."), format
);
529 /* Specify default address for `x' command.
530 The `info lines' command uses this. */
533 set_next_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
535 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
537 next_gdbarch
= gdbarch
;
540 /* Make address available to the user as $_. */
541 set_internalvar (lookup_internalvar ("_"),
542 value_from_pointer (ptr_type
, addr
));
545 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
546 after LEADIN. Print nothing if no symbolic name is found nearby.
547 Optionally also print source file and line number, if available.
548 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
549 or to interpret it as a possible C++ name and convert it back to source
550 form. However note that DO_DEMANGLE can be overridden by the specific
551 settings of the demangle and asm_demangle variables. Returns
552 non-zero if anything was printed; zero otherwise. */
555 print_address_symbolic (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
556 struct ui_file
*stream
,
557 int do_demangle
, const char *leadin
)
559 std::string name
, filename
;
564 if (build_address_symbolic (gdbarch
, addr
, do_demangle
, false, &name
,
565 &offset
, &filename
, &line
, &unmapped
))
568 gdb_puts (leadin
, stream
);
570 gdb_puts ("<*", stream
);
572 gdb_puts ("<", stream
);
573 fputs_styled (name
.c_str (), function_name_style
.style (), stream
);
575 gdb_printf (stream
, "%+d", offset
);
577 /* Append source filename and line number if desired. Give specific
578 line # of this addr, if we have it; else line # of the nearest symbol. */
579 if (print_symbol_filename
&& !filename
.empty ())
581 gdb_puts (line
== -1 ? " in " : " at ", stream
);
582 fputs_styled (filename
.c_str (), file_name_style
.style (), stream
);
584 gdb_printf (stream
, ":%d", line
);
587 gdb_puts ("*>", stream
);
589 gdb_puts (">", stream
);
594 /* See valprint.h. */
597 build_address_symbolic (struct gdbarch
*gdbarch
,
598 CORE_ADDR addr
, /* IN */
599 bool do_demangle
, /* IN */
600 bool prefer_sym_over_minsym
, /* IN */
601 std::string
*name
, /* OUT */
602 int *offset
, /* OUT */
603 std::string
*filename
, /* OUT */
605 int *unmapped
) /* OUT */
607 struct bound_minimal_symbol msymbol
;
608 struct symbol
*symbol
;
609 CORE_ADDR name_location
= 0;
610 struct obj_section
*section
= NULL
;
611 const char *name_temp
= "";
613 /* Let's say it is mapped (not unmapped). */
616 /* Determine if the address is in an overlay, and whether it is
618 if (overlay_debugging
)
620 section
= find_pc_overlay (addr
);
621 if (pc_in_unmapped_range (addr
, section
))
624 addr
= overlay_mapped_address (addr
, section
);
628 /* Try to find the address in both the symbol table and the minsyms.
629 In most cases, we'll prefer to use the symbol instead of the
630 minsym. However, there are cases (see below) where we'll choose
631 to use the minsym instead. */
633 /* This is defective in the sense that it only finds text symbols. So
634 really this is kind of pointless--we should make sure that the
635 minimal symbols have everything we need (by changing that we could
636 save some memory, but for many debug format--ELF/DWARF or
637 anything/stabs--it would be inconvenient to eliminate those minimal
639 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
640 symbol
= find_pc_sect_function (addr
, section
);
644 /* If this is a function (i.e. a code address), strip out any
645 non-address bits. For instance, display a pointer to the
646 first instruction of a Thumb function as <function>; the
647 second instruction will be <function+2>, even though the
648 pointer is <function+3>. This matches the ISA behavior. */
649 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
651 name_location
= symbol
->value_block ()->entry_pc ();
652 if (do_demangle
|| asm_demangle
)
653 name_temp
= symbol
->print_name ();
655 name_temp
= symbol
->linkage_name ();
658 if (msymbol
.minsym
!= NULL
659 && msymbol
.minsym
->has_size ()
660 && msymbol
.minsym
->size () == 0
661 && msymbol
.minsym
->type () != mst_text
662 && msymbol
.minsym
->type () != mst_text_gnu_ifunc
663 && msymbol
.minsym
->type () != mst_file_text
)
664 msymbol
.minsym
= NULL
;
666 if (msymbol
.minsym
!= NULL
)
668 /* Use the minsym if no symbol is found.
670 Additionally, use the minsym instead of a (found) symbol if
671 the following conditions all hold:
672 1) The prefer_sym_over_minsym flag is false.
673 2) The minsym address is identical to that of the address under
675 3) The symbol address is not identical to that of the address
676 under consideration. */
677 if (symbol
== NULL
||
678 (!prefer_sym_over_minsym
679 && msymbol
.value_address () == addr
680 && name_location
!= addr
))
682 /* If this is a function (i.e. a code address), strip out any
683 non-address bits. For instance, display a pointer to the
684 first instruction of a Thumb function as <function>; the
685 second instruction will be <function+2>, even though the
686 pointer is <function+3>. This matches the ISA behavior. */
687 if (msymbol
.minsym
->type () == mst_text
688 || msymbol
.minsym
->type () == mst_text_gnu_ifunc
689 || msymbol
.minsym
->type () == mst_file_text
690 || msymbol
.minsym
->type () == mst_solib_trampoline
)
691 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
694 name_location
= msymbol
.value_address ();
695 if (do_demangle
|| asm_demangle
)
696 name_temp
= msymbol
.minsym
->print_name ();
698 name_temp
= msymbol
.minsym
->linkage_name ();
701 if (symbol
== NULL
&& msymbol
.minsym
== NULL
)
704 /* If the nearest symbol is too far away, don't print anything symbolic. */
706 /* For when CORE_ADDR is larger than unsigned int, we do math in
707 CORE_ADDR. But when we detect unsigned wraparound in the
708 CORE_ADDR math, we ignore this test and print the offset,
709 because addr+max_symbolic_offset has wrapped through the end
710 of the address space back to the beginning, giving bogus comparison. */
711 if (addr
> name_location
+ max_symbolic_offset
712 && name_location
+ max_symbolic_offset
> name_location
)
715 *offset
= (LONGEST
) addr
- name_location
;
719 if (print_symbol_filename
)
721 struct symtab_and_line sal
;
723 sal
= find_pc_sect_line (addr
, section
, 0);
727 *filename
= symtab_to_filename_for_display (sal
.symtab
);
735 /* Print address ADDR symbolically on STREAM.
736 First print it as a number. Then perhaps print
737 <SYMBOL + OFFSET> after the number. */
740 print_address (struct gdbarch
*gdbarch
,
741 CORE_ADDR addr
, struct ui_file
*stream
)
743 fputs_styled (paddress (gdbarch
, addr
), address_style
.style (), stream
);
744 print_address_symbolic (gdbarch
, addr
, stream
, asm_demangle
, " ");
747 /* Return a prefix for instruction address:
748 "=> " for current instruction, else " ". */
751 pc_prefix (CORE_ADDR addr
)
753 if (has_stack_frames ())
755 frame_info_ptr frame
;
758 frame
= get_selected_frame (NULL
);
759 if (get_frame_pc_if_available (frame
, &pc
) && pc
== addr
)
765 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
766 controls whether to print the symbolic name "raw" or demangled.
767 Return non-zero if anything was printed; zero otherwise. */
770 print_address_demangle (const struct value_print_options
*opts
,
771 struct gdbarch
*gdbarch
, CORE_ADDR addr
,
772 struct ui_file
*stream
, int do_demangle
)
774 if (opts
->addressprint
)
776 fputs_styled (paddress (gdbarch
, addr
), address_style
.style (), stream
);
777 print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, " ");
781 return print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, "");
787 /* Find the address of the instruction that is INST_COUNT instructions before
788 the instruction at ADDR.
789 Since some architectures have variable-length instructions, we can't just
790 simply subtract INST_COUNT * INSN_LEN from ADDR. Instead, we use line
791 number information to locate the nearest known instruction boundary,
792 and disassemble forward from there. If we go out of the symbol range
793 during disassembling, we return the lowest address we've got so far and
794 set the number of instructions read to INST_READ. */
797 find_instruction_backward (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
798 int inst_count
, int *inst_read
)
800 /* The vector PCS is used to store instruction addresses within
802 CORE_ADDR loop_start
, loop_end
, p
;
803 std::vector
<CORE_ADDR
> pcs
;
804 struct symtab_and_line sal
;
807 loop_start
= loop_end
= addr
;
809 /* In each iteration of the outer loop, we get a pc range that ends before
810 LOOP_START, then we count and store every instruction address of the range
811 iterated in the loop.
812 If the number of instructions counted reaches INST_COUNT, return the
813 stored address that is located INST_COUNT instructions back from ADDR.
814 If INST_COUNT is not reached, we subtract the number of counted
815 instructions from INST_COUNT, and go to the next iteration. */
819 sal
= find_pc_sect_line (loop_start
, NULL
, 1);
822 /* We reach here when line info is not available. In this case,
823 we print a message and just exit the loop. The return value
824 is calculated after the loop. */
825 gdb_printf (_("No line number information available "
827 gdb_stdout
->wrap_here (2);
828 print_address (gdbarch
, loop_start
- 1, gdb_stdout
);
833 loop_end
= loop_start
;
836 /* This loop pushes instruction addresses in the range from
837 LOOP_START to LOOP_END. */
838 for (p
= loop_start
; p
< loop_end
;)
841 p
+= gdb_insn_length (gdbarch
, p
);
844 inst_count
-= pcs
.size ();
845 *inst_read
+= pcs
.size ();
847 while (inst_count
> 0);
849 /* After the loop, the vector PCS has instruction addresses of the last
850 source line we processed, and INST_COUNT has a negative value.
851 We return the address at the index of -INST_COUNT in the vector for
853 Let's assume the following instruction addresses and run 'x/-4i 0x400e'.
863 find_instruction_backward is called with INST_COUNT = 4 and expected to
864 return 0x4001. When we reach here, INST_COUNT is set to -1 because
865 it was subtracted by 2 (from Line Y) and 3 (from Line X). The value
866 4001 is located at the index 1 of the last iterated line (= Line X),
867 which is simply calculated by -INST_COUNT.
868 The case when the length of PCS is 0 means that we reached an area for
869 which line info is not available. In such case, we return LOOP_START,
870 which was the lowest instruction address that had line info. */
871 p
= pcs
.size () > 0 ? pcs
[-inst_count
] : loop_start
;
873 /* INST_READ includes all instruction addresses in a pc range. Need to
874 exclude the beginning part up to the address we're returning. That
875 is, exclude {0x4000} in the example above. */
877 *inst_read
+= inst_count
;
882 /* Backward read LEN bytes of target memory from address MEMADDR + LEN,
883 placing the results in GDB's memory from MYADDR + LEN. Returns
884 a count of the bytes actually read. */
887 read_memory_backward (struct gdbarch
*gdbarch
,
888 CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
891 int nread
; /* Number of bytes actually read. */
893 /* First try a complete read. */
894 errcode
= target_read_memory (memaddr
, myaddr
, len
);
902 /* Loop, reading one byte at a time until we get as much as we can. */
905 for (nread
= 0; nread
< len
; ++nread
)
907 errcode
= target_read_memory (--memaddr
, --myaddr
, 1);
910 /* The read was unsuccessful, so exit the loop. */
911 gdb_printf (_("Cannot access memory at address %s\n"),
912 paddress (gdbarch
, memaddr
));
920 /* Returns true if X (which is LEN bytes wide) is the number zero. */
923 integer_is_zero (const gdb_byte
*x
, int len
)
927 while (i
< len
&& x
[i
] == 0)
932 /* Find the start address of a string in which ADDR is included.
933 Basically we search for '\0' and return the next address,
934 but if OPTIONS->PRINT_MAX is smaller than the length of a string,
935 we stop searching and return the address to print characters as many as
936 PRINT_MAX from the string. */
939 find_string_backward (struct gdbarch
*gdbarch
,
940 CORE_ADDR addr
, int count
, int char_size
,
941 const struct value_print_options
*options
,
942 int *strings_counted
)
944 const int chunk_size
= 0x20;
947 int chars_to_read
= chunk_size
;
948 int chars_counted
= 0;
949 int count_original
= count
;
950 CORE_ADDR string_start_addr
= addr
;
952 gdb_assert (char_size
== 1 || char_size
== 2 || char_size
== 4);
953 gdb::byte_vector
buffer (chars_to_read
* char_size
);
954 while (count
> 0 && read_error
== 0)
958 addr
-= chars_to_read
* char_size
;
959 chars_read
= read_memory_backward (gdbarch
, addr
, buffer
.data (),
960 chars_to_read
* char_size
);
961 chars_read
/= char_size
;
962 read_error
= (chars_read
== chars_to_read
) ? 0 : 1;
963 unsigned int print_max_chars
= get_print_max_chars (options
);
964 /* Searching for '\0' from the end of buffer in backward direction. */
965 for (i
= 0; i
< chars_read
&& count
> 0 ; ++i
, ++chars_counted
)
967 int offset
= (chars_to_read
- i
- 1) * char_size
;
969 if (integer_is_zero (&buffer
[offset
], char_size
)
970 || chars_counted
== print_max_chars
)
972 /* Found '\0' or reached `print_max_chars'. As OFFSET
973 is the offset to '\0', we add CHAR_SIZE to return
974 the start address of a string. */
976 string_start_addr
= addr
+ offset
+ char_size
;
982 /* Update STRINGS_COUNTED with the actual number of loaded strings. */
983 *strings_counted
= count_original
- count
;
987 /* In error case, STRING_START_ADDR is pointing to the string that
988 was last successfully loaded. Rewind the partially loaded string. */
989 string_start_addr
-= chars_counted
* char_size
;
992 return string_start_addr
;
995 /* Examine data at address ADDR in format FMT.
996 Fetch it from memory and print on gdb_stdout. */
999 do_examine (struct format_data fmt
, struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1004 struct type
*val_type
= NULL
;
1007 struct value_print_options opts
;
1008 int need_to_update_next_address
= 0;
1009 CORE_ADDR addr_rewound
= 0;
1011 format
= fmt
.format
;
1014 next_gdbarch
= gdbarch
;
1015 next_address
= addr
;
1017 /* Instruction format implies fetch single bytes
1018 regardless of the specified size.
1019 The case of strings is handled in decode_format, only explicit
1020 size operator are not changed to 'b'. */
1026 /* Pick the appropriate size for an address. */
1027 if (gdbarch_ptr_bit (next_gdbarch
) == 64)
1029 else if (gdbarch_ptr_bit (next_gdbarch
) == 32)
1031 else if (gdbarch_ptr_bit (next_gdbarch
) == 16)
1034 /* Bad value for gdbarch_ptr_bit. */
1035 internal_error (_("failed internal consistency check"));
1039 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1040 else if (size
== 'h')
1041 val_type
= builtin_type (next_gdbarch
)->builtin_int16
;
1042 else if (size
== 'w')
1043 val_type
= builtin_type (next_gdbarch
)->builtin_int32
;
1044 else if (size
== 'g')
1045 val_type
= builtin_type (next_gdbarch
)->builtin_int64
;
1049 struct type
*char_type
= NULL
;
1051 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
1052 if type is not found. */
1054 char_type
= builtin_type (next_gdbarch
)->builtin_char16
;
1055 else if (size
== 'w')
1056 char_type
= builtin_type (next_gdbarch
)->builtin_char32
;
1058 val_type
= char_type
;
1061 if (size
!= '\0' && size
!= 'b')
1062 warning (_("Unable to display strings with "
1063 "size '%c', using 'b' instead."), size
);
1065 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1074 if (format
== 's' || format
== 'i')
1077 get_formatted_print_options (&opts
, format
);
1081 /* This is the negative repeat count case.
1082 We rewind the address based on the given repeat count and format,
1083 then examine memory from there in forward direction. */
1088 next_address
= find_instruction_backward (gdbarch
, addr
, count
,
1091 else if (format
== 's')
1093 next_address
= find_string_backward (gdbarch
, addr
, count
,
1094 val_type
->length (),
1099 next_address
= addr
- count
* val_type
->length ();
1102 /* The following call to print_formatted updates next_address in every
1103 iteration. In backward case, we store the start address here
1104 and update next_address with it before exiting the function. */
1105 addr_rewound
= (format
== 's'
1106 ? next_address
- val_type
->length ()
1108 need_to_update_next_address
= 1;
1111 /* Whether we need to print the memory tag information for the current
1113 bool print_range_tag
= true;
1114 uint32_t gsize
= gdbarch_memtag_granule_size (gdbarch
);
1116 /* Print as many objects as specified in COUNT, at most maxelts per line,
1117 with the address of the next one at the start of each line. */
1123 CORE_ADDR tag_laddr
= 0, tag_haddr
= 0;
1125 /* Print the memory tag information if requested. */
1126 if (fmt
.print_tags
&& print_range_tag
1127 && target_supports_memory_tagging ())
1129 tag_laddr
= align_down (next_address
, gsize
);
1130 tag_haddr
= align_down (next_address
+ gsize
, gsize
);
1132 struct value
*v_addr
1133 = value_from_ulongest (builtin_type (gdbarch
)->builtin_data_ptr
,
1136 if (gdbarch_tagged_address_p (current_inferior ()->arch (), v_addr
))
1138 /* Fetch the allocation tag. */
1140 = gdbarch_get_memtag (gdbarch
, v_addr
, memtag_type::allocation
);
1142 = gdbarch_memtag_to_string (gdbarch
, tag
);
1146 gdb_printf (_("<Allocation Tag %s for range [%s,%s)>\n"),
1148 paddress (gdbarch
, tag_laddr
),
1149 paddress (gdbarch
, tag_haddr
));
1152 print_range_tag
= false;
1156 gdb_puts (pc_prefix (next_address
));
1157 print_address (next_gdbarch
, next_address
, gdb_stdout
);
1164 /* Note that print_formatted sets next_address for the next
1166 last_examine_address
= next_address
;
1168 /* The value to be displayed is not fetched greedily.
1169 Instead, to avoid the possibility of a fetched value not
1170 being used, its retrieval is delayed until the print code
1171 uses it. When examining an instruction stream, the
1172 disassembler will perform its own memory fetch using just
1173 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
1174 the disassembler be modified so that LAST_EXAMINE_VALUE
1175 is left with the byte sequence from the last complete
1176 instruction fetched from memory? */
1178 = release_value (value_at_lazy (val_type
, next_address
));
1180 print_formatted (last_examine_value
.get (), size
, &opts
, gdb_stdout
);
1182 /* Display any branch delay slots following the final insn. */
1183 if (format
== 'i' && count
== 1)
1184 count
+= branch_delay_insns
;
1186 /* Update the tag range based on the current address being
1188 if (tag_haddr
<= next_address
)
1189 print_range_tag
= true;
1194 if (need_to_update_next_address
)
1195 next_address
= addr_rewound
;
1199 validate_format (struct format_data fmt
, const char *cmdname
)
1202 error (_("Size letters are meaningless in \"%s\" command."), cmdname
);
1204 error (_("Item count other than 1 is meaningless in \"%s\" command."),
1206 if (fmt
.format
== 'i')
1207 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
1208 fmt
.format
, cmdname
);
1211 /* Parse print command format string into *OPTS and update *EXPP.
1212 CMDNAME should name the current command. */
1215 print_command_parse_format (const char **expp
, const char *cmdname
,
1216 value_print_options
*opts
)
1218 const char *exp
= *expp
;
1220 /* opts->raw value might already have been set by 'set print raw-values'
1221 or by using 'print -raw-values'.
1222 So, do not set opts->raw to 0, only set it to 1 if /r is given. */
1223 if (exp
&& *exp
== '/')
1228 fmt
= decode_format (&exp
, last_format
, 0);
1229 validate_format (fmt
, cmdname
);
1230 last_format
= fmt
.format
;
1232 opts
->format
= fmt
.format
;
1233 opts
->raw
= opts
->raw
|| fmt
.raw
;
1243 /* See valprint.h. */
1246 print_value (value
*val
, const value_print_options
&opts
)
1248 /* This setting allows large arrays to be printed by limiting the
1249 number of elements that are loaded into GDB's memory; we only
1250 need to load as many array elements as we plan to print. */
1251 scoped_array_length_limiting
limit_large_arrays (opts
.print_max
);
1253 int histindex
= val
->record_latest ();
1255 annotate_value_history_begin (histindex
, val
->type ());
1257 gdb_printf ("$%d = ", histindex
);
1259 annotate_value_history_value ();
1261 print_formatted (val
, 0, &opts
, gdb_stdout
);
1264 annotate_value_history_end ();
1267 /* Returns true if memory tags should be validated. False otherwise. */
1270 should_validate_memtags (struct value
*value
)
1272 gdb_assert (value
!= nullptr && value
->type () != nullptr);
1274 if (!target_supports_memory_tagging ())
1277 enum type_code code
= value
->type ()->code ();
1279 /* Skip non-address values. */
1280 if (code
!= TYPE_CODE_PTR
1281 && !TYPE_IS_REFERENCE (value
->type ()))
1284 /* OK, we have an address value. Check we have a complete value we
1286 if (value
->optimized_out ()
1287 || !value
->entirely_available ())
1290 /* We do. Check whether it includes any tags. */
1291 return gdbarch_tagged_address_p (current_inferior ()->arch (), value
);
1294 /* Helper for parsing arguments for print_command_1. */
1296 static struct value
*
1297 process_print_command_args (const char *args
, value_print_options
*print_opts
,
1300 get_user_print_options (print_opts
);
1301 /* Override global settings with explicit options, if any. */
1302 auto group
= make_value_print_options_def_group (print_opts
);
1303 gdb::option::process_options
1304 (&args
, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER
, group
);
1306 print_command_parse_format (&args
, "print", print_opts
);
1308 const char *exp
= args
;
1310 if (exp
!= nullptr && *exp
)
1312 /* This setting allows large arrays to be printed by limiting the
1313 number of elements that are loaded into GDB's memory; we only
1314 need to load as many array elements as we plan to print. */
1315 scoped_array_length_limiting
limit_large_arrays (print_opts
->print_max
);
1317 /* VOIDPRINT is true to indicate that we do want to print a void
1318 value, so invert it for parse_expression. */
1319 parser_flags flags
= 0;
1321 flags
= PARSER_VOID_CONTEXT
;
1322 expression_up expr
= parse_expression (exp
, nullptr, flags
);
1323 return expr
->evaluate ();
1326 return access_value_history (0);
1329 /* Implementation of the "print" and "call" commands. */
1332 print_command_1 (const char *args
, int voidprint
)
1334 value_print_options print_opts
;
1336 struct value
*val
= process_print_command_args (args
, &print_opts
, voidprint
);
1338 if (voidprint
|| (val
&& val
->type () &&
1339 val
->type ()->code () != TYPE_CODE_VOID
))
1341 /* If memory tagging validation is on, check if the tag is valid. */
1342 if (print_opts
.memory_tag_violations
)
1346 gdbarch
*arch
= current_inferior ()->arch ();
1348 if (should_validate_memtags (val
)
1349 && !gdbarch_memtag_matches_p (arch
, val
))
1351 /* Fetch the logical tag. */
1353 = gdbarch_get_memtag (arch
, val
, memtag_type::logical
);
1354 std::string ltag
= gdbarch_memtag_to_string (arch
, tag
);
1356 /* Fetch the allocation tag. */
1357 tag
= gdbarch_get_memtag (arch
, val
,
1358 memtag_type::allocation
);
1359 std::string atag
= gdbarch_memtag_to_string (arch
, tag
);
1361 gdb_printf (_("Logical tag (%s) does not match the "
1362 "allocation tag (%s).\n"),
1363 ltag
.c_str (), atag
.c_str ());
1366 catch (gdb_exception_error
&ex
)
1368 if (ex
.error
== TARGET_CLOSE_ERROR
)
1371 gdb_printf (gdb_stderr
,
1372 _("Could not validate memory tag: %s\n"),
1373 ex
.message
->c_str ());
1377 print_value (val
, print_opts
);
1381 /* Called from command completion function to skip over /FMT
1382 specifications, allowing the rest of the line to be completed. Returns
1383 true if the /FMT is at the end of the current line and there is nothing
1384 left to complete, otherwise false is returned.
1386 In either case *ARGS can be updated to point after any part of /FMT that
1389 This function is designed so that trying to complete '/' will offer no
1390 completions, the user needs to insert the format specification
1391 themselves. Trying to complete '/FMT' (where FMT is any non-empty set
1392 of alpha-numeric characters) will cause readline to insert a single
1393 space, setting the user up to enter the expression. */
1396 skip_over_slash_fmt (completion_tracker
&tracker
, const char **args
)
1398 const char *text
= *args
;
1403 tracker
.set_use_custom_word_point (true);
1405 if (text
[1] == '\0')
1407 /* The user tried to complete after typing just the '/' character
1408 of the /FMT string. Step the completer past the '/', but we
1409 don't offer any completions. */
1415 /* The user has typed some characters after the '/', we assume
1416 this is a complete /FMT string, first skip over it. */
1417 text
= skip_to_space (text
);
1421 /* We're at the end of the input string. The user has typed
1422 '/FMT' and asked for a completion. Push an empty
1423 completion string, this will cause readline to insert a
1424 space so the user now has '/FMT '. */
1426 tracker
.add_completion (make_unique_xstrdup (text
));
1430 /* The user has already typed things after the /FMT, skip the
1431 whitespace and return false. Whoever called this function
1432 should then try to complete what comes next. */
1434 text
= skip_spaces (text
);
1438 tracker
.advance_custom_word_point_by (text
- *args
);
1446 /* See valprint.h. */
1449 print_command_completer (struct cmd_list_element
*ignore
,
1450 completion_tracker
&tracker
,
1451 const char *text
, const char * /*word*/)
1453 const auto group
= make_value_print_options_def_group (nullptr);
1454 if (gdb::option::complete_options
1455 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_REQUIRE_DELIMITER
, group
))
1458 if (skip_over_slash_fmt (tracker
, &text
))
1461 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
1462 expression_completer (ignore
, tracker
, text
, word
);
1466 print_command (const char *exp
, int from_tty
)
1468 print_command_1 (exp
, true);
1471 /* Same as print, except it doesn't print void results. */
1473 call_command (const char *exp
, int from_tty
)
1475 print_command_1 (exp
, false);
1478 /* Implementation of the "output" command. */
1481 output_command (const char *exp
, int from_tty
)
1485 struct format_data fmt
;
1486 struct value_print_options opts
;
1491 if (exp
&& *exp
== '/')
1494 fmt
= decode_format (&exp
, 0, 0);
1495 validate_format (fmt
, "output");
1496 format
= fmt
.format
;
1499 expression_up expr
= parse_expression (exp
);
1501 val
= expr
->evaluate ();
1503 annotate_value_begin (val
->type ());
1505 get_formatted_print_options (&opts
, format
);
1508 /* This setting allows large arrays to be printed by limiting the
1509 number of elements that are loaded into GDB's memory; we only
1510 need to load as many array elements as we plan to print. */
1511 scoped_array_length_limiting
limit_large_arrays (opts
.print_max
);
1513 print_formatted (val
, fmt
.size
, &opts
, gdb_stdout
);
1515 annotate_value_end ();
1517 gdb_flush (gdb_stdout
);
1521 set_command (const char *exp
, int from_tty
)
1523 expression_up expr
= parse_expression (exp
);
1525 switch (expr
->first_opcode ())
1527 case UNOP_PREINCREMENT
:
1528 case UNOP_POSTINCREMENT
:
1529 case UNOP_PREDECREMENT
:
1530 case UNOP_POSTDECREMENT
:
1532 case BINOP_ASSIGN_MODIFY
:
1537 (_("Expression is not an assignment (and might have no effect)"));
1544 info_symbol_command (const char *arg
, int from_tty
)
1546 struct minimal_symbol
*msymbol
;
1547 CORE_ADDR addr
, sect_addr
;
1549 unsigned int offset
;
1552 error_no_arg (_("address"));
1554 addr
= parse_and_eval_address (arg
);
1555 for (objfile
*objfile
: current_program_space
->objfiles ())
1556 for (obj_section
*osect
: objfile
->sections ())
1558 /* Only process each object file once, even if there's a separate
1560 if (objfile
->separate_debug_objfile_backlink
)
1563 sect_addr
= overlay_mapped_address (addr
, osect
);
1565 if (osect
->addr () <= sect_addr
&& sect_addr
< osect
->endaddr ()
1567 = lookup_minimal_symbol_by_pc_section (sect_addr
,
1570 const char *obj_name
, *mapped
, *sec_name
, *msym_name
;
1571 const char *loc_string
;
1574 offset
= sect_addr
- msymbol
->value_address (objfile
);
1575 mapped
= section_is_mapped (osect
) ? _("mapped") : _("unmapped");
1576 sec_name
= osect
->the_bfd_section
->name
;
1577 msym_name
= msymbol
->print_name ();
1579 /* Don't print the offset if it is zero.
1580 We assume there's no need to handle i18n of "sym + offset". */
1581 std::string string_holder
;
1584 string_holder
= string_printf ("%s + %u", msym_name
, offset
);
1585 loc_string
= string_holder
.c_str ();
1588 loc_string
= msym_name
;
1590 gdb_assert (osect
->objfile
&& objfile_name (osect
->objfile
));
1591 obj_name
= objfile_name (osect
->objfile
);
1593 if (current_program_space
->multi_objfile_p ())
1594 if (pc_in_unmapped_range (addr
, osect
))
1595 if (section_is_overlay (osect
))
1596 gdb_printf (_("%s in load address range of "
1597 "%s overlay section %s of %s\n"),
1598 loc_string
, mapped
, sec_name
, obj_name
);
1600 gdb_printf (_("%s in load address range of "
1601 "section %s of %s\n"),
1602 loc_string
, sec_name
, obj_name
);
1604 if (section_is_overlay (osect
))
1605 gdb_printf (_("%s in %s overlay section %s of %s\n"),
1606 loc_string
, mapped
, sec_name
, obj_name
);
1608 gdb_printf (_("%s in section %s of %s\n"),
1609 loc_string
, sec_name
, obj_name
);
1611 if (pc_in_unmapped_range (addr
, osect
))
1612 if (section_is_overlay (osect
))
1613 gdb_printf (_("%s in load address range of %s overlay "
1615 loc_string
, mapped
, sec_name
);
1618 (_("%s in load address range of section %s\n"),
1619 loc_string
, sec_name
);
1621 if (section_is_overlay (osect
))
1622 gdb_printf (_("%s in %s overlay section %s\n"),
1623 loc_string
, mapped
, sec_name
);
1625 gdb_printf (_("%s in section %s\n"),
1626 loc_string
, sec_name
);
1630 gdb_printf (_("No symbol matches %s.\n"), arg
);
1634 info_address_command (const char *exp
, int from_tty
)
1636 struct gdbarch
*gdbarch
;
1639 struct bound_minimal_symbol msymbol
;
1641 struct obj_section
*section
;
1642 CORE_ADDR load_addr
, context_pc
= 0;
1643 struct field_of_this_result is_a_field_of_this
;
1646 error (_("Argument required."));
1648 sym
= lookup_symbol (exp
, get_selected_block (&context_pc
), VAR_DOMAIN
,
1649 &is_a_field_of_this
).symbol
;
1652 if (is_a_field_of_this
.type
!= NULL
)
1654 gdb_printf ("Symbol \"");
1655 fprintf_symbol (gdb_stdout
, exp
,
1656 current_language
->la_language
, DMGL_ANSI
);
1657 gdb_printf ("\" is a field of the local class variable ");
1658 if (current_language
->la_language
== language_objc
)
1659 gdb_printf ("`self'\n"); /* ObjC equivalent of "this" */
1661 gdb_printf ("`this'\n");
1665 msymbol
= lookup_bound_minimal_symbol (exp
);
1667 if (msymbol
.minsym
!= NULL
)
1669 struct objfile
*objfile
= msymbol
.objfile
;
1671 gdbarch
= objfile
->arch ();
1672 load_addr
= msymbol
.value_address ();
1674 gdb_printf ("Symbol \"");
1675 fprintf_symbol (gdb_stdout
, exp
,
1676 current_language
->la_language
, DMGL_ANSI
);
1677 gdb_printf ("\" is at ");
1678 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1680 gdb_printf (" in a file compiled without debugging");
1681 section
= msymbol
.minsym
->obj_section (objfile
);
1682 if (section_is_overlay (section
))
1684 load_addr
= overlay_unmapped_address (load_addr
, section
);
1685 gdb_printf (",\n -- loaded at ");
1686 fputs_styled (paddress (gdbarch
, load_addr
),
1687 address_style
.style (),
1689 gdb_printf (" in overlay section %s",
1690 section
->the_bfd_section
->name
);
1695 error (_("No symbol \"%s\" in current context."), exp
);
1699 gdb_printf ("Symbol \"");
1700 gdb_puts (sym
->print_name ());
1701 gdb_printf ("\" is ");
1702 val
= sym
->value_longest ();
1703 if (sym
->is_objfile_owned ())
1704 section
= sym
->obj_section (sym
->objfile ());
1707 gdbarch
= sym
->arch ();
1709 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
1711 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, context_pc
,
1717 switch (sym
->aclass ())
1720 case LOC_CONST_BYTES
:
1721 gdb_printf ("constant");
1725 gdb_printf ("a label at address ");
1726 load_addr
= sym
->value_address ();
1727 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1729 if (section_is_overlay (section
))
1731 load_addr
= overlay_unmapped_address (load_addr
, section
);
1732 gdb_printf (",\n -- loaded at ");
1733 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1735 gdb_printf (" in overlay section %s",
1736 section
->the_bfd_section
->name
);
1741 gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
1744 /* GDBARCH is the architecture associated with the objfile the symbol
1745 is defined in; the target architecture may be different, and may
1746 provide additional registers. However, we do not know the target
1747 architecture at this point. We assume the objfile architecture
1748 will contain all the standard registers that occur in debug info
1750 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1752 if (sym
->is_argument ())
1753 gdb_printf (_("an argument in register %s"),
1754 gdbarch_register_name (gdbarch
, regno
));
1756 gdb_printf (_("a variable in register %s"),
1757 gdbarch_register_name (gdbarch
, regno
));
1761 gdb_printf (_("static storage at address "));
1762 load_addr
= sym
->value_address ();
1763 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1765 if (section_is_overlay (section
))
1767 load_addr
= overlay_unmapped_address (load_addr
, section
);
1768 gdb_printf (_(",\n -- loaded at "));
1769 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1771 gdb_printf (_(" in overlay section %s"),
1772 section
->the_bfd_section
->name
);
1776 case LOC_REGPARM_ADDR
:
1777 /* Note comment at LOC_REGISTER. */
1778 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1779 gdb_printf (_("address of an argument in register %s"),
1780 gdbarch_register_name (gdbarch
, regno
));
1784 gdb_printf (_("an argument at offset %ld"), val
);
1788 gdb_printf (_("a local variable at frame offset %ld"), val
);
1792 gdb_printf (_("a reference argument at offset %ld"), val
);
1796 gdb_printf (_("a typedef"));
1800 gdb_printf (_("a function at address "));
1801 load_addr
= sym
->value_block ()->entry_pc ();
1802 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1804 if (section_is_overlay (section
))
1806 load_addr
= overlay_unmapped_address (load_addr
, section
);
1807 gdb_printf (_(",\n -- loaded at "));
1808 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1810 gdb_printf (_(" in overlay section %s"),
1811 section
->the_bfd_section
->name
);
1815 case LOC_UNRESOLVED
:
1817 struct bound_minimal_symbol msym
;
1819 msym
= lookup_bound_minimal_symbol (sym
->linkage_name ());
1820 if (msym
.minsym
== NULL
)
1821 gdb_printf ("unresolved");
1824 section
= msym
.obj_section ();
1827 && (section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
1829 load_addr
= CORE_ADDR (msym
.minsym
->unrelocated_address ());
1830 gdb_printf (_("a thread-local variable at offset %s "
1831 "in the thread-local storage for `%s'"),
1832 paddress (gdbarch
, load_addr
),
1833 objfile_name (section
->objfile
));
1837 load_addr
= msym
.value_address ();
1838 gdb_printf (_("static storage at address "));
1839 fputs_styled (paddress (gdbarch
, load_addr
),
1840 address_style
.style (), gdb_stdout
);
1841 if (section_is_overlay (section
))
1843 load_addr
= overlay_unmapped_address (load_addr
, section
);
1844 gdb_printf (_(",\n -- loaded at "));
1845 fputs_styled (paddress (gdbarch
, load_addr
),
1846 address_style
.style (),
1848 gdb_printf (_(" in overlay section %s"),
1849 section
->the_bfd_section
->name
);
1856 case LOC_OPTIMIZED_OUT
:
1857 gdb_printf (_("optimized out"));
1861 gdb_printf (_("of unknown (botched) type"));
1869 x_command (const char *exp
, int from_tty
)
1871 struct format_data fmt
;
1874 fmt
.format
= last_format
? last_format
: 'x';
1875 fmt
.print_tags
= last_print_tags
;
1876 fmt
.size
= last_size
;
1880 /* If there is no expression and no format, use the most recent
1882 if (exp
== nullptr && last_count
> 0)
1883 fmt
.count
= last_count
;
1885 if (exp
&& *exp
== '/')
1887 const char *tmp
= exp
+ 1;
1889 fmt
= decode_format (&tmp
, last_format
, last_size
);
1893 last_count
= fmt
.count
;
1895 /* If we have an expression, evaluate it and use it as the address. */
1897 if (exp
!= 0 && *exp
!= 0)
1899 expression_up expr
= parse_expression (exp
);
1900 /* Cause expression not to be there any more if this command is
1901 repeated with Newline. But don't clobber a user-defined
1902 command's definition. */
1904 set_repeat_arguments ("");
1905 val
= expr
->evaluate ();
1906 if (TYPE_IS_REFERENCE (val
->type ()))
1907 val
= coerce_ref (val
);
1908 /* In rvalue contexts, such as this, functions are coerced into
1909 pointers to functions. This makes "x/i main" work. */
1910 if (val
->type ()->code () == TYPE_CODE_FUNC
1911 && val
->lval () == lval_memory
)
1912 next_address
= val
->address ();
1914 next_address
= value_as_address (val
);
1916 next_gdbarch
= expr
->gdbarch
;
1920 error_no_arg (_("starting display address"));
1922 do_examine (fmt
, next_gdbarch
, next_address
);
1924 /* If the examine succeeds, we remember its size and format for next
1925 time. Set last_size to 'b' for strings. */
1926 if (fmt
.format
== 's')
1929 last_size
= fmt
.size
;
1930 last_format
= fmt
.format
;
1932 /* Remember tag-printing setting. */
1933 last_print_tags
= fmt
.print_tags
;
1935 /* Set a couple of internal variables if appropriate. */
1936 if (last_examine_value
!= nullptr)
1938 /* Make last address examined available to the user as $_. Use
1939 the correct pointer type. */
1940 struct type
*pointer_type
1941 = lookup_pointer_type (last_examine_value
->type ());
1942 set_internalvar (lookup_internalvar ("_"),
1943 value_from_pointer (pointer_type
,
1944 last_examine_address
));
1946 /* Make contents of last address examined available to the user
1947 as $__. If the last value has not been fetched from memory
1948 then don't fetch it now; instead mark it by voiding the $__
1950 if (last_examine_value
->lazy ())
1951 clear_internalvar (lookup_internalvar ("__"));
1953 set_internalvar (lookup_internalvar ("__"), last_examine_value
.get ());
1957 /* Command completion for the 'display' and 'x' commands. */
1960 display_and_x_command_completer (struct cmd_list_element
*ignore
,
1961 completion_tracker
&tracker
,
1962 const char *text
, const char * /*word*/)
1964 if (skip_over_slash_fmt (tracker
, &text
))
1967 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
1968 expression_completer (ignore
, tracker
, text
, word
);
1973 /* Add an expression to the auto-display chain.
1974 Specify the expression. */
1977 display_command (const char *arg
, int from_tty
)
1979 struct format_data fmt
;
1980 struct display
*newobj
;
1981 const char *exp
= arg
;
1992 fmt
= decode_format (&exp
, 0, 0);
1993 if (fmt
.size
&& fmt
.format
== 0)
1995 if (fmt
.format
== 'i' || fmt
.format
== 's')
2006 innermost_block_tracker tracker
;
2007 expression_up expr
= parse_expression (exp
, &tracker
);
2009 newobj
= new display (exp
, std::move (expr
), fmt
,
2010 current_program_space
, tracker
.block ());
2011 all_displays
.emplace_back (newobj
);
2014 do_one_display (newobj
);
2019 /* Clear out the display_chain. Done when new symtabs are loaded,
2020 since this invalidates the types stored in many expressions. */
2025 all_displays
.clear ();
2028 /* Delete the auto-display DISPLAY. */
2031 delete_display (struct display
*display
)
2033 gdb_assert (display
!= NULL
);
2035 auto iter
= std::find_if (all_displays
.begin (),
2036 all_displays
.end (),
2037 [=] (const std::unique_ptr
<struct display
> &item
)
2039 return item
.get () == display
;
2041 gdb_assert (iter
!= all_displays
.end ());
2042 all_displays
.erase (iter
);
2045 /* Call FUNCTION on each of the displays whose numbers are given in
2046 ARGS. DATA is passed unmodified to FUNCTION. */
2049 map_display_numbers (const char *args
,
2050 gdb::function_view
<void (struct display
*)> function
)
2055 error_no_arg (_("one or more display numbers"));
2057 number_or_range_parser
parser (args
);
2059 while (!parser
.finished ())
2061 const char *p
= parser
.cur_tok ();
2063 num
= parser
.get_number ();
2065 warning (_("bad display number at or near '%s'"), p
);
2068 auto iter
= std::find_if (all_displays
.begin (),
2069 all_displays
.end (),
2070 [=] (const std::unique_ptr
<display
> &item
)
2072 return item
->number
== num
;
2074 if (iter
== all_displays
.end ())
2075 gdb_printf (_("No display number %d.\n"), num
);
2077 function (iter
->get ());
2082 /* "undisplay" command. */
2085 undisplay_command (const char *args
, int from_tty
)
2089 if (query (_("Delete all auto-display expressions? ")))
2095 map_display_numbers (args
, delete_display
);
2099 /* Display a single auto-display.
2100 Do nothing if the display cannot be printed in the current context,
2101 or if the display is disabled. */
2104 do_one_display (struct display
*d
)
2106 int within_current_scope
;
2111 /* The expression carries the architecture that was used at parse time.
2112 This is a problem if the expression depends on architecture features
2113 (e.g. register numbers), and the current architecture is now different.
2114 For example, a display statement like "display/i $pc" is expected to
2115 display the PC register of the current architecture, not the arch at
2116 the time the display command was given. Therefore, we re-parse the
2117 expression if the current architecture has changed. */
2118 if (d
->exp
!= NULL
&& d
->exp
->gdbarch
!= get_current_arch ())
2129 innermost_block_tracker tracker
;
2130 d
->exp
= parse_expression (d
->exp_string
.c_str (), &tracker
);
2131 d
->block
= tracker
.block ();
2133 catch (const gdb_exception_error
&ex
)
2135 /* Can't re-parse the expression. Disable this display item. */
2136 d
->enabled_p
= false;
2137 warning (_("Unable to display \"%s\": %s"),
2138 d
->exp_string
.c_str (), ex
.what ());
2145 if (d
->pspace
== current_program_space
)
2146 within_current_scope
= d
->block
->contains (get_selected_block (0),
2149 within_current_scope
= 0;
2152 within_current_scope
= 1;
2153 if (!within_current_scope
)
2156 scoped_restore save_display_number
2157 = make_scoped_restore (¤t_display_number
, d
->number
);
2159 annotate_display_begin ();
2160 gdb_printf ("%d", d
->number
);
2161 annotate_display_number_end ();
2166 annotate_display_format ();
2169 if (d
->format
.count
!= 1)
2170 gdb_printf ("%d", d
->format
.count
);
2171 gdb_printf ("%c", d
->format
.format
);
2172 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
2173 gdb_printf ("%c", d
->format
.size
);
2176 annotate_display_expression ();
2178 gdb_puts (d
->exp_string
.c_str ());
2179 annotate_display_expression_end ();
2181 if (d
->format
.count
!= 1 || d
->format
.format
== 'i')
2186 annotate_display_value ();
2193 val
= d
->exp
->evaluate ();
2194 addr
= value_as_address (val
);
2195 if (d
->format
.format
== 'i')
2196 addr
= gdbarch_addr_bits_remove (d
->exp
->gdbarch
, addr
);
2197 do_examine (d
->format
, d
->exp
->gdbarch
, addr
);
2199 catch (const gdb_exception_error
&ex
)
2201 gdb_printf (_("%p[<error: %s>%p]\n"),
2202 metadata_style
.style ().ptr (), ex
.what (),
2208 struct value_print_options opts
;
2210 annotate_display_format ();
2212 if (d
->format
.format
)
2213 gdb_printf ("/%c ", d
->format
.format
);
2215 annotate_display_expression ();
2217 gdb_puts (d
->exp_string
.c_str ());
2218 annotate_display_expression_end ();
2222 annotate_display_expression ();
2224 get_formatted_print_options (&opts
, d
->format
.format
);
2225 opts
.raw
= d
->format
.raw
;
2231 val
= d
->exp
->evaluate ();
2232 print_formatted (val
, d
->format
.size
, &opts
, gdb_stdout
);
2234 catch (const gdb_exception_error
&ex
)
2236 fprintf_styled (gdb_stdout
, metadata_style
.style (),
2237 _("<error: %s>"), ex
.what ());
2243 annotate_display_end ();
2245 gdb_flush (gdb_stdout
);
2248 /* Display all of the values on the auto-display chain which can be
2249 evaluated in the current scope. */
2254 for (auto &d
: all_displays
)
2255 do_one_display (d
.get ());
2258 /* Delete the auto-display which we were in the process of displaying.
2259 This is done when there is an error or a signal. */
2262 disable_display (int num
)
2264 for (auto &d
: all_displays
)
2265 if (d
->number
== num
)
2267 d
->enabled_p
= false;
2270 gdb_printf (_("No display number %d.\n"), num
);
2274 disable_current_display (void)
2276 if (current_display_number
>= 0)
2278 disable_display (current_display_number
);
2279 gdb_printf (gdb_stderr
,
2280 _("Disabling display %d to "
2281 "avoid infinite recursion.\n"),
2282 current_display_number
);
2284 current_display_number
= -1;
2288 info_display_command (const char *ignore
, int from_tty
)
2290 if (all_displays
.empty ())
2291 gdb_printf (_("There are no auto-display expressions now.\n"));
2293 gdb_printf (_("Auto-display expressions now in effect:\n\
2294 Num Enb Expression\n"));
2296 for (auto &d
: all_displays
)
2298 gdb_printf ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
2300 gdb_printf ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
2302 else if (d
->format
.format
)
2303 gdb_printf ("/%c ", d
->format
.format
);
2304 gdb_puts (d
->exp_string
.c_str ());
2305 if (d
->block
&& !d
->block
->contains (get_selected_block (0), true))
2306 gdb_printf (_(" (cannot be evaluated in the current context)"));
2311 /* Implementation of both the "disable display" and "enable display"
2312 commands. ENABLE decides what to do. */
2315 enable_disable_display_command (const char *args
, int from_tty
, bool enable
)
2319 for (auto &d
: all_displays
)
2320 d
->enabled_p
= enable
;
2324 map_display_numbers (args
,
2325 [=] (struct display
*d
)
2327 d
->enabled_p
= enable
;
2331 /* The "enable display" command. */
2334 enable_display_command (const char *args
, int from_tty
)
2336 enable_disable_display_command (args
, from_tty
, true);
2339 /* The "disable display" command. */
2342 disable_display_command (const char *args
, int from_tty
)
2344 enable_disable_display_command (args
, from_tty
, false);
2347 /* display_chain items point to blocks and expressions. Some expressions in
2348 turn may point to symbols.
2349 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
2350 obstack_free'd when a shared library is unloaded.
2351 Clear pointers that are about to become dangling.
2352 Both .exp and .block fields will be restored next time we need to display
2353 an item by re-parsing .exp_string field in the new execution context. */
2356 clear_dangling_display_expressions (struct objfile
*objfile
)
2358 program_space
*pspace
= objfile
->pspace
;
2359 if (objfile
->separate_debug_objfile_backlink
)
2361 objfile
= objfile
->separate_debug_objfile_backlink
;
2362 gdb_assert (objfile
->pspace
== pspace
);
2365 for (auto &d
: all_displays
)
2367 if (d
->pspace
!= pspace
)
2370 struct objfile
*bl_objf
= nullptr;
2371 if (d
->block
!= nullptr)
2373 bl_objf
= d
->block
->objfile ();
2374 if (bl_objf
->separate_debug_objfile_backlink
!= nullptr)
2375 bl_objf
= bl_objf
->separate_debug_objfile_backlink
;
2378 if (bl_objf
== objfile
2379 || (d
->exp
!= nullptr && d
->exp
->uses_objfile (objfile
)))
2388 /* Print the value in stack frame FRAME of a variable specified by a
2389 struct symbol. NAME is the name to print; if NULL then VAR's print
2390 name will be used. STREAM is the ui_file on which to print the
2391 value. INDENT specifies the number of indent levels to print
2392 before printing the variable name.
2394 This function invalidates FRAME. */
2397 print_variable_and_value (const char *name
, struct symbol
*var
,
2398 frame_info_ptr frame
,
2399 struct ui_file
*stream
, int indent
)
2403 name
= var
->print_name ();
2405 gdb_printf (stream
, "%*s%ps = ", 2 * indent
, "",
2406 styled_string (variable_name_style
.style (), name
));
2411 struct value_print_options opts
;
2413 /* READ_VAR_VALUE needs a block in order to deal with non-local
2414 references (i.e. to handle nested functions). In this context, we
2415 print variables that are local to this frame, so we can avoid passing
2417 val
= read_var_value (var
, NULL
, frame
);
2418 get_user_print_options (&opts
);
2419 opts
.deref_ref
= true;
2420 common_val_print_checked (val
, stream
, indent
, &opts
, current_language
);
2422 /* common_val_print invalidates FRAME when a pretty printer calls inferior
2426 catch (const gdb_exception_error
&except
)
2428 fprintf_styled (stream
, metadata_style
.style (),
2429 "<error reading variable %s (%s)>", name
,
2433 gdb_printf (stream
, "\n");
2436 /* Subroutine of ui_printf to simplify it.
2437 Print VALUE to STREAM using FORMAT.
2438 VALUE is a C-style string either on the target or
2439 in a GDB internal variable. */
2442 printf_c_string (struct ui_file
*stream
, const char *format
,
2443 struct value
*value
)
2445 gdb::byte_vector str
;
2447 if (((value
->type ()->code () != TYPE_CODE_PTR
&& value
->lval () == lval_internalvar
)
2448 || value
->type ()->code () == TYPE_CODE_ARRAY
)
2449 && c_is_string_type_p (value
->type ()))
2451 size_t len
= value
->type ()->length ();
2453 /* Copy the internal var value to TEM_STR and append a terminating null
2454 character. This protects against corrupted C-style strings that lack
2455 the terminating null char. It also allows Ada-style strings (not
2456 null terminated) to be printed without problems. */
2457 str
.resize (len
+ 1);
2459 memcpy (str
.data (), value
->contents ().data (), len
);
2464 CORE_ADDR tem
= value_as_address (value
);;
2469 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2470 gdb_printf (stream
, format
, "(null)");
2475 /* This is a %s argument. Build the string in STR which is
2477 gdb_assert (str
.size () == 0);
2479 for (len
= 0;; len
++)
2485 read_memory (tem
+ len
, &c
, 1);
2486 if (!exceeds_max_value_size (len
+ 1))
2492 if (exceeds_max_value_size (len
+ 1))
2493 error (_("printed string requires %s bytes, which is more than "
2494 "max-value-size"), plongest (len
+ 1));
2496 /* We will have passed through the above loop at least once, and will
2497 only exit the loop when we have pushed a zero byte onto the end of
2499 gdb_assert (str
.size () > 0);
2500 gdb_assert (str
.back () == 0);
2504 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2505 gdb_printf (stream
, format
, (char *) str
.data ());
2509 /* Subroutine of ui_printf to simplify it.
2510 Print VALUE to STREAM using FORMAT.
2511 VALUE is a wide C-style string on the target or
2512 in a GDB internal variable. */
2515 printf_wide_c_string (struct ui_file
*stream
, const char *format
,
2516 struct value
*value
)
2518 const gdb_byte
*str
;
2520 struct gdbarch
*gdbarch
= value
->type ()->arch ();
2521 struct type
*wctype
= lookup_typename (current_language
,
2522 "wchar_t", NULL
, 0);
2523 int wcwidth
= wctype
->length ();
2524 gdb::optional
<gdb::byte_vector
> tem_str
;
2526 if (value
->lval () == lval_internalvar
2527 && c_is_string_type_p (value
->type ()))
2529 str
= value
->contents ().data ();
2530 len
= value
->type ()->length ();
2534 CORE_ADDR tem
= value_as_address (value
);
2539 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2540 gdb_printf (stream
, format
, "(null)");
2545 /* This is a %s argument. Find the length of the string. */
2546 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2549 for (len
= 0;; len
+= wcwidth
)
2553 if (!exceeds_max_value_size (len
+ wcwidth
))
2555 tem_str
->resize (tem_str
->size () + wcwidth
);
2556 dst
= tem_str
->data () + len
;
2560 /* We still need to check for the null-character, so we need
2561 somewhere to place the data read from the inferior. We
2562 can't keep growing TEM_STR, it's gotten too big, so
2563 instead just read the new character into the start of
2564 TEMS_STR. This will corrupt the previously read contents,
2565 but we're not going to print this string anyway, we just
2566 want to know how big it would have been so we can tell the
2567 user in the error message (see below).
2569 And we know there will be space in this buffer so long as
2570 WCWIDTH is smaller than our LONGEST type, the
2571 max-value-size can't be smaller than a LONGEST. */
2572 dst
= tem_str
->data ();
2574 read_memory (tem
+ len
, dst
, wcwidth
);
2575 if (extract_unsigned_integer (dst
, wcwidth
, byte_order
) == 0)
2579 if (exceeds_max_value_size (len
+ wcwidth
))
2580 error (_("printed string requires %s bytes, which is more than "
2581 "max-value-size"), plongest (len
+ wcwidth
));
2583 str
= tem_str
->data ();
2586 auto_obstack output
;
2588 convert_between_encodings (target_wide_charset (gdbarch
),
2591 &output
, translit_char
);
2592 obstack_grow_str0 (&output
, "");
2595 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2596 gdb_printf (stream
, format
, obstack_base (&output
));
2600 /* Subroutine of ui_printf to simplify it.
2601 Print VALUE, a floating point value, to STREAM using FORMAT. */
2604 printf_floating (struct ui_file
*stream
, const char *format
,
2605 struct value
*value
, enum argclass argclass
)
2607 /* Parameter data. */
2608 struct type
*param_type
= value
->type ();
2609 struct gdbarch
*gdbarch
= param_type
->arch ();
2611 /* Determine target type corresponding to the format string. */
2612 struct type
*fmt_type
;
2616 fmt_type
= builtin_type (gdbarch
)->builtin_double
;
2618 case long_double_arg
:
2619 fmt_type
= builtin_type (gdbarch
)->builtin_long_double
;
2621 case dec32float_arg
:
2622 fmt_type
= builtin_type (gdbarch
)->builtin_decfloat
;
2624 case dec64float_arg
:
2625 fmt_type
= builtin_type (gdbarch
)->builtin_decdouble
;
2627 case dec128float_arg
:
2628 fmt_type
= builtin_type (gdbarch
)->builtin_declong
;
2631 gdb_assert_not_reached ("unexpected argument class");
2634 /* To match the traditional GDB behavior, the conversion is
2635 done differently depending on the type of the parameter:
2637 - if the parameter has floating-point type, it's value
2638 is converted to the target type;
2640 - otherwise, if the parameter has a type that is of the
2641 same size as a built-in floating-point type, the value
2642 bytes are interpreted as if they were of that type, and
2643 then converted to the target type (this is not done for
2644 decimal floating-point argument classes);
2646 - otherwise, if the source value has an integer value,
2647 it's value is converted to the target type;
2649 - otherwise, an error is raised.
2651 In either case, the result of the conversion is a byte buffer
2652 formatted in the target format for the target type. */
2654 if (fmt_type
->code () == TYPE_CODE_FLT
)
2656 param_type
= float_type_from_length (param_type
);
2657 if (param_type
!= value
->type ())
2658 value
= value_from_contents (param_type
,
2659 value
->contents ().data ());
2662 value
= value_cast (fmt_type
, value
);
2664 /* Convert the value to a string and print it. */
2666 = target_float_to_string (value
->contents ().data (), fmt_type
, format
);
2667 gdb_puts (str
.c_str (), stream
);
2670 /* Subroutine of ui_printf to simplify it.
2671 Print VALUE, a target pointer, to STREAM using FORMAT. */
2674 printf_pointer (struct ui_file
*stream
, const char *format
,
2675 struct value
*value
)
2677 /* We avoid the host's %p because pointers are too
2678 likely to be the wrong size. The only interesting
2679 modifier for %p is a width; extract that, and then
2680 handle %p as glibc would: %#x or a literal "(nil)". */
2682 #ifdef PRINTF_HAS_LONG_LONG
2683 long long val
= value_as_long (value
);
2685 long val
= value_as_long (value
);
2688 /* Build the new output format in FMT. */
2691 /* Copy up to the leading %. */
2692 const char *p
= format
;
2695 int is_percent
= (*p
== '%');
2697 fmt
.push_back (*p
++);
2701 fmt
.push_back (*p
++);
2708 fmt
.push_back ('#');
2710 /* Copy any width or flags. Only the "-" flag is valid for pointers
2711 -- see the format_pieces constructor. */
2712 while (*p
== '-' || (*p
>= '0' && *p
< '9'))
2713 fmt
.push_back (*p
++);
2715 gdb_assert (*p
== 'p' && *(p
+ 1) == '\0');
2718 #ifdef PRINTF_HAS_LONG_LONG
2719 fmt
.push_back ('l');
2721 fmt
.push_back ('l');
2722 fmt
.push_back ('x');
2724 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2725 gdb_printf (stream
, fmt
.c_str (), val
);
2730 fmt
.push_back ('s');
2732 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2733 gdb_printf (stream
, fmt
.c_str (), "(nil)");
2738 /* printf "printf format string" ARG to STREAM. */
2741 ui_printf (const char *arg
, struct ui_file
*stream
)
2743 const char *s
= arg
;
2744 std::vector
<struct value
*> val_args
;
2747 error_no_arg (_("format-control string and values to print"));
2749 s
= skip_spaces (s
);
2751 /* A format string should follow, enveloped in double quotes. */
2753 error (_("Bad format string, missing '\"'."));
2755 format_pieces
fpieces (&s
, false, true);
2758 error (_("Bad format string, non-terminated '\"'."));
2760 s
= skip_spaces (s
);
2762 if (*s
!= ',' && *s
!= 0)
2763 error (_("Invalid argument syntax"));
2767 s
= skip_spaces (s
);
2772 const char *current_substring
;
2775 for (auto &&piece
: fpieces
)
2776 if (piece
.argclass
!= literal_piece
)
2779 /* Now, parse all arguments and evaluate them.
2780 Store the VALUEs in VAL_ARGS. */
2787 val_args
.push_back (parse_to_comma_and_eval (&s1
));
2794 if (val_args
.size () != nargs_wanted
)
2795 error (_("Wrong number of arguments for specified format-string"));
2797 /* Now actually print them. */
2799 for (auto &&piece
: fpieces
)
2801 current_substring
= piece
.string
;
2802 switch (piece
.argclass
)
2805 printf_c_string (stream
, current_substring
, val_args
[i
]);
2807 case wide_string_arg
:
2808 printf_wide_c_string (stream
, current_substring
, val_args
[i
]);
2812 struct gdbarch
*gdbarch
= val_args
[i
]->type ()->arch ();
2813 struct type
*wctype
= lookup_typename (current_language
,
2814 "wchar_t", NULL
, 0);
2815 struct type
*valtype
;
2816 const gdb_byte
*bytes
;
2818 valtype
= val_args
[i
]->type ();
2819 if (valtype
->length () != wctype
->length ()
2820 || valtype
->code () != TYPE_CODE_INT
)
2821 error (_("expected wchar_t argument for %%lc"));
2823 bytes
= val_args
[i
]->contents ().data ();
2825 auto_obstack output
;
2827 convert_between_encodings (target_wide_charset (gdbarch
),
2829 bytes
, valtype
->length (),
2831 &output
, translit_char
);
2832 obstack_grow_str0 (&output
, "");
2835 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2836 gdb_printf (stream
, current_substring
,
2837 obstack_base (&output
));
2842 #ifdef PRINTF_HAS_LONG_LONG
2844 long long val
= value_as_long (val_args
[i
]);
2847 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2848 gdb_printf (stream
, current_substring
, val
);
2853 error (_("long long not supported in printf"));
2857 int val
= value_as_long (val_args
[i
]);
2860 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2861 gdb_printf (stream
, current_substring
, val
);
2867 long val
= value_as_long (val_args
[i
]);
2870 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2871 gdb_printf (stream
, current_substring
, val
);
2877 size_t val
= value_as_long (val_args
[i
]);
2880 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2881 gdb_printf (stream
, current_substring
, val
);
2885 /* Handles floating-point values. */
2887 case long_double_arg
:
2888 case dec32float_arg
:
2889 case dec64float_arg
:
2890 case dec128float_arg
:
2891 printf_floating (stream
, current_substring
, val_args
[i
],
2895 printf_pointer (stream
, current_substring
, val_args
[i
]);
2899 value_print_options print_opts
;
2900 get_user_print_options (&print_opts
);
2902 if (current_substring
[2] == '[')
2904 std::string
args (¤t_substring
[3],
2905 strlen (¤t_substring
[3]) - 1);
2907 const char *args_ptr
= args
.c_str ();
2909 /* Override global settings with explicit options, if
2912 = make_value_print_options_def_group (&print_opts
);
2913 gdb::option::process_options
2914 (&args_ptr
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
,
2917 if (*args_ptr
!= '\0')
2918 error (_("unexpected content in print options: %s"),
2922 print_formatted (val_args
[i
], 0, &print_opts
, stream
);
2926 /* Print a portion of the format string that has no
2927 directives. Note that this will not include any
2928 ordinary %-specs, but it might include "%%". That is
2929 why we use gdb_printf and not gdb_puts here.
2930 Also, we pass a dummy argument because some platforms
2931 have modified GCC to include -Wformat-security by
2932 default, which will warn here if there is no
2935 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2936 gdb_printf (stream
, current_substring
, 0);
2940 internal_error (_("failed internal consistency check"));
2942 /* Maybe advance to the next argument. */
2943 if (piece
.argclass
!= literal_piece
)
2949 /* Implement the "printf" command. */
2952 printf_command (const char *arg
, int from_tty
)
2954 ui_printf (arg
, gdb_stdout
);
2955 gdb_stdout
->reset_style ();
2956 gdb_stdout
->wrap_here (0);
2957 gdb_stdout
->flush ();
2960 /* Implement the "eval" command. */
2963 eval_command (const char *arg
, int from_tty
)
2967 ui_printf (arg
, &stb
);
2969 std::string expanded
= insert_user_defined_cmd_args (stb
.c_str ());
2971 execute_command (expanded
.c_str (), from_tty
);
2974 /* Convenience function for error checking in memory-tag commands. */
2977 show_addr_not_tagged (CORE_ADDR address
)
2979 error (_("Address %s not in a region mapped with a memory tagging flag."),
2980 paddress (current_inferior ()->arch (), address
));
2983 /* Convenience function for error checking in memory-tag commands. */
2986 show_memory_tagging_unsupported (void)
2988 error (_("Memory tagging not supported or disabled by the current"
2992 /* Implement the "memory-tag" prefix command. */
2995 memory_tag_command (const char *arg
, int from_tty
)
2997 help_list (memory_tag_list
, "memory-tag ", all_commands
, gdb_stdout
);
3000 /* Helper for print-logical-tag and print-allocation-tag. */
3003 memory_tag_print_tag_command (const char *args
, enum memtag_type tag_type
)
3005 if (args
== nullptr)
3006 error_no_arg (_("address or pointer"));
3008 /* Parse args into a value. If the value is a pointer or an address,
3009 then fetch the logical or allocation tag. */
3010 value_print_options print_opts
;
3012 struct value
*val
= process_print_command_args (args
, &print_opts
, true);
3013 gdbarch
*arch
= current_inferior ()->arch ();
3015 /* If the address is not in a region memory mapped with a memory tagging
3016 flag, it is no use trying to access/manipulate its allocation tag.
3018 It is OK to manipulate the logical tag though. */
3019 if (tag_type
== memtag_type::allocation
3020 && !gdbarch_tagged_address_p (arch
, val
))
3021 show_addr_not_tagged (value_as_address (val
));
3023 value
*tag_value
= gdbarch_get_memtag (arch
, val
, tag_type
);
3024 std::string tag
= gdbarch_memtag_to_string (arch
, tag_value
);
3027 gdb_printf (_("%s tag unavailable.\n"),
3029 == memtag_type::logical
? "Logical" : "Allocation");
3031 struct value
*v_tag
= process_print_command_args (tag
.c_str (),
3034 print_opts
.output_format
= 'x';
3035 print_value (v_tag
, print_opts
);
3038 /* Implement the "memory-tag print-logical-tag" command. */
3041 memory_tag_print_logical_tag_command (const char *args
, int from_tty
)
3043 if (!target_supports_memory_tagging ())
3044 show_memory_tagging_unsupported ();
3046 memory_tag_print_tag_command (args
, memtag_type::logical
);
3049 /* Implement the "memory-tag print-allocation-tag" command. */
3052 memory_tag_print_allocation_tag_command (const char *args
, int from_tty
)
3054 if (!target_supports_memory_tagging ())
3055 show_memory_tagging_unsupported ();
3057 memory_tag_print_tag_command (args
, memtag_type::allocation
);
3060 /* Parse ARGS and extract ADDR and TAG.
3061 ARGS should have format <expression> <tag bytes>. */
3064 parse_with_logical_tag_input (const char *args
, struct value
**val
,
3065 gdb::byte_vector
&tags
,
3066 value_print_options
*print_opts
)
3068 /* Fetch the address. */
3069 std::string address_string
= extract_string_maybe_quoted (&args
);
3071 /* Parse the address into a value. */
3072 *val
= process_print_command_args (address_string
.c_str (), print_opts
,
3075 /* Fetch the tag bytes. */
3076 std::string tag_string
= extract_string_maybe_quoted (&args
);
3078 /* Validate the input. */
3079 if (address_string
.empty () || tag_string
.empty ())
3080 error (_("Missing arguments."));
3082 if (tag_string
.length () != 2)
3083 error (_("Error parsing tags argument. The tag should be 2 digits."));
3085 tags
= hex2bin (tag_string
.c_str ());
3088 /* Implement the "memory-tag with-logical-tag" command. */
3091 memory_tag_with_logical_tag_command (const char *args
, int from_tty
)
3093 if (!target_supports_memory_tagging ())
3094 show_memory_tagging_unsupported ();
3096 if (args
== nullptr)
3097 error_no_arg (_("<address> <tag>"));
3099 gdb::byte_vector tags
;
3101 value_print_options print_opts
;
3102 gdbarch
*arch
= current_inferior ()->arch ();
3104 /* Parse the input. */
3105 parse_with_logical_tag_input (args
, &val
, tags
, &print_opts
);
3107 /* Setting the logical tag is just a local operation that does not touch
3108 any memory from the target. Given an input value, we modify the value
3109 to include the appropriate tag.
3111 For this reason we need to cast the argument value to a
3112 (void *) pointer. This is so we have the right type for the gdbarch
3113 hook to manipulate the value and insert the tag.
3115 Otherwise, this would fail if, for example, GDB parsed the argument value
3116 into an int-sized value and the pointer value has a type of greater
3119 /* Cast to (void *). */
3120 val
= value_cast (builtin_type (current_inferior ()->arch ())->builtin_data_ptr
,
3123 /* Length doesn't matter for a logical tag. Pass 0. */
3124 if (!gdbarch_set_memtags (arch
, val
, 0, tags
, memtag_type::logical
))
3125 gdb_printf (_("Could not update the logical tag data.\n"));
3128 /* Always print it in hex format. */
3129 print_opts
.output_format
= 'x';
3130 print_value (val
, print_opts
);
3134 /* Parse ARGS and extract ADDR, LENGTH and TAGS. */
3137 parse_set_allocation_tag_input (const char *args
, struct value
**val
,
3138 size_t *length
, gdb::byte_vector
&tags
)
3140 /* Fetch the address. */
3141 std::string address_string
= extract_string_maybe_quoted (&args
);
3143 /* Parse the address into a value. */
3144 value_print_options print_opts
;
3145 *val
= process_print_command_args (address_string
.c_str (), &print_opts
,
3148 /* Fetch the length. */
3149 std::string length_string
= extract_string_maybe_quoted (&args
);
3151 /* Fetch the tag bytes. */
3152 std::string tags_string
= extract_string_maybe_quoted (&args
);
3154 /* Validate the input. */
3155 if (address_string
.empty () || length_string
.empty () || tags_string
.empty ())
3156 error (_("Missing arguments."));
3159 const char *trailer
= nullptr;
3160 LONGEST parsed_length
= strtoulst (length_string
.c_str (), &trailer
, 10);
3162 if (errno
!= 0 || (trailer
!= nullptr && trailer
[0] != '\0'))
3163 error (_("Error parsing length argument."));
3165 if (parsed_length
<= 0)
3166 error (_("Invalid zero or negative length."));
3168 *length
= parsed_length
;
3170 if (tags_string
.length () % 2)
3171 error (_("Error parsing tags argument. Tags should be 2 digits per byte."));
3173 tags
= hex2bin (tags_string
.c_str ());
3175 /* If the address is not in a region memory mapped with a memory tagging
3176 flag, it is no use trying to access/manipulate its allocation tag. */
3177 if (!gdbarch_tagged_address_p (current_inferior ()->arch (), *val
))
3178 show_addr_not_tagged (value_as_address (*val
));
3181 /* Implement the "memory-tag set-allocation-tag" command.
3182 ARGS should be in the format <address> <length> <tags>. */
3185 memory_tag_set_allocation_tag_command (const char *args
, int from_tty
)
3187 if (!target_supports_memory_tagging ())
3188 show_memory_tagging_unsupported ();
3190 if (args
== nullptr)
3191 error_no_arg (_("<starting address> <length> <tag bytes>"));
3193 gdb::byte_vector tags
;
3197 /* Parse the input. */
3198 parse_set_allocation_tag_input (args
, &val
, &length
, tags
);
3200 if (!gdbarch_set_memtags (current_inferior ()->arch (), val
, length
, tags
,
3201 memtag_type::allocation
))
3202 gdb_printf (_("Could not update the allocation tag(s).\n"));
3204 gdb_printf (_("Allocation tag(s) updated successfully.\n"));
3207 /* Implement the "memory-tag check" command. */
3210 memory_tag_check_command (const char *args
, int from_tty
)
3212 if (!target_supports_memory_tagging ())
3213 show_memory_tagging_unsupported ();
3215 if (args
== nullptr)
3216 error_no_arg (_("address or pointer"));
3218 /* Parse the expression into a value. If the value is an address or
3219 pointer, then check its logical tag against the allocation tag. */
3220 value_print_options print_opts
;
3222 struct value
*val
= process_print_command_args (args
, &print_opts
, true);
3223 gdbarch
*arch
= current_inferior ()->arch ();
3225 /* If the address is not in a region memory mapped with a memory tagging
3226 flag, it is no use trying to access/manipulate its allocation tag. */
3227 if (!gdbarch_tagged_address_p (arch
, val
))
3228 show_addr_not_tagged (value_as_address (val
));
3230 CORE_ADDR addr
= value_as_address (val
);
3232 /* Check if the tag is valid. */
3233 if (!gdbarch_memtag_matches_p (arch
, val
))
3235 value
*tag
= gdbarch_get_memtag (arch
, val
, memtag_type::logical
);
3236 std::string ltag
= gdbarch_memtag_to_string (arch
, tag
);
3238 tag
= gdbarch_get_memtag (arch
, val
, memtag_type::allocation
);
3239 std::string atag
= gdbarch_memtag_to_string (arch
, tag
);
3241 gdb_printf (_("Logical tag (%s) does not match"
3242 " the allocation tag (%s) for address %s.\n"),
3243 ltag
.c_str (), atag
.c_str (),
3244 paddress (current_inferior ()->arch (), addr
));
3249 = gdbarch_get_memtag (current_inferior ()->arch (), val
,
3250 memtag_type::logical
);
3252 = gdbarch_memtag_to_string (current_inferior ()->arch (), tag
);
3254 gdb_printf (_("Memory tags for address %s match (%s).\n"),
3255 paddress (current_inferior ()->arch (), addr
), ltag
.c_str ());
3259 void _initialize_printcmd ();
3261 _initialize_printcmd ()
3263 struct cmd_list_element
*c
;
3265 current_display_number
= -1;
3267 gdb::observers::free_objfile
.attach (clear_dangling_display_expressions
,
3270 add_info ("address", info_address_command
,
3271 _("Describe where symbol SYM is stored.\n\
3272 Usage: info address SYM"));
3274 add_info ("symbol", info_symbol_command
, _("\
3275 Describe what symbol is at location ADDR.\n\
3276 Usage: info symbol ADDR\n\
3277 Only for symbols with fixed locations (global or static scope)."));
3279 c
= add_com ("x", class_vars
, x_command
, _("\
3280 Examine memory: x/FMT ADDRESS.\n\
3281 ADDRESS is an expression for the memory address to examine.\n\
3282 FMT is a repeat count followed by a format letter and a size letter.\n\
3283 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
3284 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
3285 and z(hex, zero padded on the left).\n\
3286 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
3287 The specified number of objects of the specified size are printed\n\
3288 according to the format. If a negative number is specified, memory is\n\
3289 examined backward from the address.\n\n\
3290 Defaults for format and size letters are those previously used.\n\
3291 Default count is 1. Default address is following last thing printed\n\
3292 with this command or \"print\"."));
3293 set_cmd_completer_handle_brkchars (c
, display_and_x_command_completer
);
3295 add_info ("display", info_display_command
, _("\
3296 Expressions to display when program stops, with code numbers.\n\
3297 Usage: info display"));
3299 add_cmd ("undisplay", class_vars
, undisplay_command
, _("\
3300 Cancel some expressions to be displayed when program stops.\n\
3301 Usage: undisplay [NUM]...\n\
3302 Arguments are the code numbers of the expressions to stop displaying.\n\
3303 No argument means cancel all automatic-display expressions.\n\
3304 \"delete display\" has the same effect as this command.\n\
3305 Do \"info display\" to see current list of code numbers."),
3308 c
= add_com ("display", class_vars
, display_command
, _("\
3309 Print value of expression EXP each time the program stops.\n\
3310 Usage: display[/FMT] EXP\n\
3311 /FMT may be used before EXP as in the \"print\" command.\n\
3312 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
3313 as in the \"x\" command, and then EXP is used to get the address to examine\n\
3314 and examining is done as in the \"x\" command.\n\n\
3315 With no argument, display all currently requested auto-display expressions.\n\
3316 Use \"undisplay\" to cancel display requests previously made."));
3317 set_cmd_completer_handle_brkchars (c
, display_and_x_command_completer
);
3319 add_cmd ("display", class_vars
, enable_display_command
, _("\
3320 Enable some expressions to be displayed when program stops.\n\
3321 Usage: enable display [NUM]...\n\
3322 Arguments are the code numbers of the expressions to resume displaying.\n\
3323 No argument means enable all automatic-display expressions.\n\
3324 Do \"info display\" to see current list of code numbers."), &enablelist
);
3326 add_cmd ("display", class_vars
, disable_display_command
, _("\
3327 Disable some expressions to be displayed when program stops.\n\
3328 Usage: disable display [NUM]...\n\
3329 Arguments are the code numbers of the expressions to stop displaying.\n\
3330 No argument means disable all automatic-display expressions.\n\
3331 Do \"info display\" to see current list of code numbers."), &disablelist
);
3333 add_cmd ("display", class_vars
, undisplay_command
, _("\
3334 Cancel some expressions to be displayed when program stops.\n\
3335 Usage: delete display [NUM]...\n\
3336 Arguments are the code numbers of the expressions to stop displaying.\n\
3337 No argument means cancel all automatic-display expressions.\n\
3338 Do \"info display\" to see current list of code numbers."), &deletelist
);
3340 add_com ("printf", class_vars
, printf_command
, _("\
3341 Formatted printing, like the C \"printf\" function.\n\
3342 Usage: printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
3343 This supports most C printf format specifications, like %s, %d, etc."));
3345 add_com ("output", class_vars
, output_command
, _("\
3346 Like \"print\" but don't put in value history and don't print newline.\n\
3347 Usage: output EXP\n\
3348 This is useful in user-defined commands."));
3350 add_prefix_cmd ("set", class_vars
, set_command
, _("\
3351 Evaluate expression EXP and assign result to variable VAR.\n\
3352 Usage: set VAR = EXP\n\
3353 This uses assignment syntax appropriate for the current language\n\
3354 (VAR = EXP or VAR := EXP for example).\n\
3355 VAR may be a debugger \"convenience\" variable (names starting\n\
3356 with $), a register (a few standard names starting with $), or an actual\n\
3357 variable in the program being debugged. EXP is any valid expression.\n\
3358 Use \"set variable\" for variables with names identical to set subcommands.\n\
3360 With a subcommand, this command modifies parts of the gdb environment.\n\
3361 You can see these environment settings with the \"show\" command."),
3362 &setlist
, 1, &cmdlist
);
3364 /* "call" is the same as "set", but handy for dbx users to call fns. */
3365 c
= add_com ("call", class_vars
, call_command
, _("\
3366 Call a function in the program.\n\
3368 The argument is the function name and arguments, in the notation of the\n\
3369 current working language. The result is printed and saved in the value\n\
3370 history, if it is not void."));
3371 set_cmd_completer_handle_brkchars (c
, print_command_completer
);
3373 cmd_list_element
*set_variable_cmd
3374 = add_cmd ("variable", class_vars
, set_command
, _("\
3375 Evaluate expression EXP and assign result to variable VAR.\n\
3376 Usage: set variable VAR = EXP\n\
3377 This uses assignment syntax appropriate for the current language\n\
3378 (VAR = EXP or VAR := EXP for example).\n\
3379 VAR may be a debugger \"convenience\" variable (names starting\n\
3380 with $), a register (a few standard names starting with $), or an actual\n\
3381 variable in the program being debugged. EXP is any valid expression.\n\
3382 This may usually be abbreviated to simply \"set\"."),
3384 add_alias_cmd ("var", set_variable_cmd
, class_vars
, 0, &setlist
);
3386 const auto print_opts
= make_value_print_options_def_group (nullptr);
3388 static const std::string print_help
= gdb::option::build_help (_("\
3389 Print value of expression EXP.\n\
3390 Usage: print [[OPTION]... --] [/FMT] [EXP]\n\
3395 Note: because this command accepts arbitrary expressions, if you\n\
3396 specify any command option, you must use a double dash (\"--\")\n\
3397 to mark the end of option processing. E.g.: \"print -o -- myobj\".\n\
3399 Variables accessible are those of the lexical environment of the selected\n\
3400 stack frame, plus all those whose scope is global or an entire file.\n\
3402 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
3403 $$NUM refers to NUM'th value back from the last one.\n\
3404 Names starting with $ refer to registers (with the values they would have\n\
3405 if the program were to return to the stack frame now selected, restoring\n\
3406 all registers saved by frames farther in) or else to debugger\n\
3407 \"convenience\" variables (any such name not a known register).\n\
3408 Use assignment expressions to give values to convenience variables.\n\
3410 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
3411 @ is a binary operator for treating consecutive data objects\n\
3412 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
3413 element is FOO, whose second element is stored in the space following\n\
3414 where FOO is stored, etc. FOO must be an expression whose value\n\
3415 resides in memory.\n\
3417 EXP may be preceded with /FMT, where FMT is a format letter\n\
3418 but no count or size letter (see \"x\" command)."),
3421 cmd_list_element
*print_cmd
3422 = add_com ("print", class_vars
, print_command
, print_help
.c_str ());
3423 set_cmd_completer_handle_brkchars (print_cmd
, print_command_completer
);
3424 add_com_alias ("p", print_cmd
, class_vars
, 1);
3425 add_com_alias ("inspect", print_cmd
, class_vars
, 1);
3427 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class
,
3428 &max_symbolic_offset
, _("\
3429 Set the largest offset that will be printed in <SYMBOL+1234> form."), _("\
3430 Show the largest offset that will be printed in <SYMBOL+1234> form."), _("\
3431 Tell GDB to only display the symbolic form of an address if the\n\
3432 offset between the closest earlier symbol and the address is less than\n\
3433 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
3434 to always print the symbolic form of an address if any symbol precedes\n\
3435 it. Zero is equivalent to \"unlimited\"."),
3437 show_max_symbolic_offset
,
3438 &setprintlist
, &showprintlist
);
3439 add_setshow_boolean_cmd ("symbol-filename", no_class
,
3440 &print_symbol_filename
, _("\
3441 Set printing of source filename and line number with <SYMBOL>."), _("\
3442 Show printing of source filename and line number with <SYMBOL>."), NULL
,
3444 show_print_symbol_filename
,
3445 &setprintlist
, &showprintlist
);
3447 add_com ("eval", no_class
, eval_command
, _("\
3448 Construct a GDB command and then evaluate it.\n\
3449 Usage: eval \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
3450 Convert the arguments to a string as \"printf\" would, but then\n\
3451 treat this string as a command line, and evaluate it."));
3453 /* Memory tagging commands. */
3454 add_prefix_cmd ("memory-tag", class_vars
, memory_tag_command
, _("\
3455 Generic command for printing and manipulating memory tag properties."),
3456 &memory_tag_list
, 0, &cmdlist
);
3457 add_cmd ("print-logical-tag", class_vars
,
3458 memory_tag_print_logical_tag_command
,
3459 ("Print the logical tag from POINTER.\n\
3460 Usage: memory-tag print-logical-tag <POINTER>.\n\
3461 <POINTER> is an expression that evaluates to a pointer.\n\
3462 Print the logical tag contained in POINTER. The tag interpretation is\n\
3463 architecture-specific."),
3465 add_cmd ("print-allocation-tag", class_vars
,
3466 memory_tag_print_allocation_tag_command
,
3467 _("Print the allocation tag for ADDRESS.\n\
3468 Usage: memory-tag print-allocation-tag <ADDRESS>.\n\
3469 <ADDRESS> is an expression that evaluates to a memory address.\n\
3470 Print the allocation tag associated with the memory address ADDRESS.\n\
3471 The tag interpretation is architecture-specific."),
3473 add_cmd ("with-logical-tag", class_vars
, memory_tag_with_logical_tag_command
,
3474 _("Print a POINTER with a specific logical TAG.\n\
3475 Usage: memory-tag with-logical-tag <POINTER> <TAG>\n\
3476 <POINTER> is an expression that evaluates to a pointer.\n\
3477 <TAG> is a sequence of hex bytes that is interpreted by the architecture\n\
3478 as a single memory tag."),
3480 add_cmd ("set-allocation-tag", class_vars
,
3481 memory_tag_set_allocation_tag_command
,
3482 _("Set the allocation tag(s) for a memory range.\n\
3483 Usage: memory-tag set-allocation-tag <ADDRESS> <LENGTH> <TAG_BYTES>\n\
3484 <ADDRESS> is an expression that evaluates to a memory address\n\
3485 <LENGTH> is the number of bytes that is added to <ADDRESS> to calculate\n\
3486 the memory range.\n\
3487 <TAG_BYTES> is a sequence of hex bytes that is interpreted by the\n\
3488 architecture as one or more memory tags.\n\
3489 Sets the tags of the memory range [ADDRESS, ADDRESS + LENGTH)\n\
3492 If the number of tags is greater than or equal to the number of tag granules\n\
3493 in the [ADDRESS, ADDRESS + LENGTH) range, only the tags up to the\n\
3494 number of tag granules are updated.\n\
3496 If the number of tags is less than the number of tag granules, then the\n\
3497 command is a fill operation. The TAG_BYTES are interpreted as a pattern\n\
3498 that gets repeated until the number of tag granules in the memory range\n\
3499 [ADDRESS, ADDRESS + LENGTH) is updated."),
3501 add_cmd ("check", class_vars
, memory_tag_check_command
,
3502 _("Validate a pointer's logical tag against the allocation tag.\n\
3503 Usage: memory-tag check <POINTER>\n\
3504 <POINTER> is an expression that evaluates to a pointer\n\
3505 Fetch the logical and allocation tags for POINTER and compare them\n\
3506 for equality. If the tags do not match, print additional information about\n\
3507 the tag mismatch."),