1 /* Print values for GNU debugger GDB.
3 Copyright (C) 1986-2018 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/>. */
26 #include "expression.h"
30 #include "breakpoint.h"
32 #include "gdb-demangle.h"
35 #include "symfile.h" /* for overlay functions */
36 #include "objfiles.h" /* ditto */
37 #include "completer.h" /* for completion functions */
41 #include "target-float.h"
42 #include "observable.h"
44 #include "parser-defs.h"
46 #include "arch-utils.h"
47 #include "cli/cli-utils.h"
48 #include "cli/cli-script.h"
51 #include "common/byte-vector.h"
53 /* Last specified output format. */
55 static char last_format
= 0;
57 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
59 static char last_size
= 'w';
61 /* Last specified count for the 'x' command. */
63 static int last_count
;
65 /* Default address to examine next, and associated architecture. */
67 static struct gdbarch
*next_gdbarch
;
68 static CORE_ADDR next_address
;
70 /* Number of delay instructions following current disassembled insn. */
72 static int branch_delay_insns
;
74 /* Last address examined. */
76 static CORE_ADDR last_examine_address
;
78 /* Contents of last address examined.
79 This is not valid past the end of the `x' command! */
81 static value_ref_ptr last_examine_value
;
83 /* Largest offset between a symbolic value and an address, that will be
84 printed as `0x1234 <symbol+offset>'. */
86 static unsigned int max_symbolic_offset
= UINT_MAX
;
88 show_max_symbolic_offset (struct ui_file
*file
, int from_tty
,
89 struct cmd_list_element
*c
, const char *value
)
91 fprintf_filtered (file
,
92 _("The largest offset that will be "
93 "printed in <symbol+1234> form is %s.\n"),
97 /* Append the source filename and linenumber of the symbol when
98 printing a symbolic value as `<symbol at filename:linenum>' if set. */
99 static int print_symbol_filename
= 0;
101 show_print_symbol_filename (struct ui_file
*file
, int from_tty
,
102 struct cmd_list_element
*c
, const char *value
)
104 fprintf_filtered (file
, _("Printing of source filename and "
105 "line number with <symbol> is %s.\n"),
109 /* Number of auto-display expression currently being displayed.
110 So that we can disable it if we get a signal within it.
111 -1 when not doing one. */
113 static int current_display_number
;
117 /* Chain link to next auto-display item. */
118 struct display
*next
;
120 /* The expression as the user typed it. */
123 /* Expression to be evaluated and displayed. */
126 /* Item number of this auto-display item. */
129 /* Display format specified. */
130 struct format_data format
;
132 /* Program space associated with `block'. */
133 struct program_space
*pspace
;
135 /* Innermost block required by this expression when evaluated. */
136 const struct block
*block
;
138 /* Status of this display (enabled or disabled). */
142 /* Chain of expressions whose values should be displayed
143 automatically each time the program stops. */
145 static struct display
*display_chain
;
147 static int display_number
;
149 /* Walk the following statement or block through all displays.
150 ALL_DISPLAYS_SAFE does so even if the statement deletes the current
153 #define ALL_DISPLAYS(B) \
154 for (B = display_chain; B; B = B->next)
156 #define ALL_DISPLAYS_SAFE(B,TMP) \
157 for (B = display_chain; \
158 B ? (TMP = B->next, 1): 0; \
161 /* Prototypes for local functions. */
163 static void do_one_display (struct display
*);
166 /* Decode a format specification. *STRING_PTR should point to it.
167 OFORMAT and OSIZE are used as defaults for the format and size
168 if none are given in the format specification.
169 If OSIZE is zero, then the size field of the returned value
170 should be set only if a size is explicitly specified by the
172 The structure returned describes all the data
173 found in the specification. In addition, *STRING_PTR is advanced
174 past the specification and past all whitespace following it. */
176 static struct format_data
177 decode_format (const char **string_ptr
, int oformat
, int osize
)
179 struct format_data val
;
180 const char *p
= *string_ptr
;
192 if (*p
>= '0' && *p
<= '9')
193 val
.count
*= atoi (p
);
194 while (*p
>= '0' && *p
<= '9')
197 /* Now process size or format letters that follow. */
201 if (*p
== 'b' || *p
== 'h' || *p
== 'w' || *p
== 'g')
208 else if (*p
>= 'a' && *p
<= 'z')
214 *string_ptr
= skip_spaces (p
);
216 /* Set defaults for format and size if not specified. */
217 if (val
.format
== '?')
221 /* Neither has been specified. */
222 val
.format
= oformat
;
226 /* If a size is specified, any format makes a reasonable
227 default except 'i'. */
228 val
.format
= oformat
== 'i' ? 'x' : oformat
;
230 else if (val
.size
== '?')
234 /* Pick the appropriate size for an address. This is deferred
235 until do_examine when we know the actual architecture to use.
236 A special size value of 'a' is used to indicate this case. */
237 val
.size
= osize
? 'a' : osize
;
240 /* Floating point has to be word or giantword. */
241 if (osize
== 'w' || osize
== 'g')
244 /* Default it to giantword if the last used size is not
246 val
.size
= osize
? 'g' : osize
;
249 /* Characters default to one byte. */
250 val
.size
= osize
? 'b' : osize
;
253 /* Display strings with byte size chars unless explicitly
259 /* The default is the size most recently specified. */
266 /* Print value VAL on stream according to OPTIONS.
267 Do not end with a newline.
268 SIZE is the letter for the size of datum being printed.
269 This is used to pad hex numbers so they line up. SIZE is 0
270 for print / output and set for examine. */
273 print_formatted (struct value
*val
, int size
,
274 const struct value_print_options
*options
,
275 struct ui_file
*stream
)
277 struct type
*type
= check_typedef (value_type (val
));
278 int len
= TYPE_LENGTH (type
);
280 if (VALUE_LVAL (val
) == lval_memory
)
281 next_address
= value_address (val
) + len
;
285 switch (options
->format
)
289 struct type
*elttype
= value_type (val
);
291 next_address
= (value_address (val
)
292 + val_print_string (elttype
, NULL
,
293 value_address (val
), -1,
294 stream
, options
) * len
);
299 /* We often wrap here if there are long symbolic names. */
301 next_address
= (value_address (val
)
302 + gdb_print_insn (get_type_arch (type
),
303 value_address (val
), stream
,
304 &branch_delay_insns
));
309 if (options
->format
== 0 || options
->format
== 's'
310 || TYPE_CODE (type
) == TYPE_CODE_REF
311 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
312 || TYPE_CODE (type
) == TYPE_CODE_STRING
313 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
314 || TYPE_CODE (type
) == TYPE_CODE_UNION
315 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
316 value_print (val
, stream
, options
);
318 /* User specified format, so don't look to the type to tell us
320 val_print_scalar_formatted (type
,
321 value_embedded_offset (val
),
323 options
, size
, stream
);
326 /* Return builtin floating point type of same length as TYPE.
327 If no such type is found, return TYPE itself. */
329 float_type_from_length (struct type
*type
)
331 struct gdbarch
*gdbarch
= get_type_arch (type
);
332 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
334 if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_float
))
335 type
= builtin
->builtin_float
;
336 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_double
))
337 type
= builtin
->builtin_double
;
338 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_long_double
))
339 type
= builtin
->builtin_long_double
;
344 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
345 according to OPTIONS and SIZE on STREAM. Formats s and i are not
346 supported at this level. */
349 print_scalar_formatted (const gdb_byte
*valaddr
, struct type
*type
,
350 const struct value_print_options
*options
,
351 int size
, struct ui_file
*stream
)
353 struct gdbarch
*gdbarch
= get_type_arch (type
);
354 unsigned int len
= TYPE_LENGTH (type
);
355 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
357 /* String printing should go through val_print_scalar_formatted. */
358 gdb_assert (options
->format
!= 's');
360 /* If the value is a pointer, and pointers and addresses are not the
361 same, then at this point, the value's length (in target bytes) is
362 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
363 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
364 len
= gdbarch_addr_bit (gdbarch
) / TARGET_CHAR_BIT
;
366 /* If we are printing it as unsigned, truncate it in case it is actually
367 a negative signed value (e.g. "print/u (short)-1" should print 65535
368 (if shorts are 16 bits) instead of 4294967295). */
369 if (options
->format
!= 'c'
370 && (options
->format
!= 'd' || TYPE_UNSIGNED (type
)))
372 if (len
< TYPE_LENGTH (type
) && byte_order
== BFD_ENDIAN_BIG
)
373 valaddr
+= TYPE_LENGTH (type
) - len
;
376 if (size
!= 0 && (options
->format
== 'x' || options
->format
== 't'))
378 /* Truncate to fit. */
395 error (_("Undefined output size \"%c\"."), size
);
397 if (newlen
< len
&& byte_order
== BFD_ENDIAN_BIG
)
398 valaddr
+= len
- newlen
;
402 /* Historically gdb has printed floats by first casting them to a
403 long, and then printing the long. PR cli/16242 suggests changing
404 this to using C-style hex float format. */
405 gdb::byte_vector converted_float_bytes
;
406 if (TYPE_CODE (type
) == TYPE_CODE_FLT
407 && (options
->format
== 'o'
408 || options
->format
== 'x'
409 || options
->format
== 't'
410 || options
->format
== 'z'
411 || options
->format
== 'd'
412 || options
->format
== 'u'))
414 LONGEST val_long
= unpack_long (type
, valaddr
);
415 converted_float_bytes
.resize (TYPE_LENGTH (type
));
416 store_signed_integer (converted_float_bytes
.data (), TYPE_LENGTH (type
),
417 byte_order
, val_long
);
418 valaddr
= converted_float_bytes
.data ();
421 /* Printing a non-float type as 'f' will interpret the data as if it were
422 of a floating-point type of the same length, if that exists. Otherwise,
423 the data is printed as integer. */
424 char format
= options
->format
;
425 if (format
== 'f' && TYPE_CODE (type
) != TYPE_CODE_FLT
)
427 type
= float_type_from_length (type
);
428 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
435 print_octal_chars (stream
, valaddr
, len
, byte_order
);
438 print_decimal_chars (stream
, valaddr
, len
, true, byte_order
);
441 print_decimal_chars (stream
, valaddr
, len
, false, byte_order
);
444 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
446 print_decimal_chars (stream
, valaddr
, len
, !TYPE_UNSIGNED (type
),
452 print_floating (valaddr
, type
, stream
);
456 print_binary_chars (stream
, valaddr
, len
, byte_order
, size
> 0);
459 print_hex_chars (stream
, valaddr
, len
, byte_order
, size
> 0);
462 print_hex_chars (stream
, valaddr
, len
, byte_order
, true);
466 struct value_print_options opts
= *options
;
468 LONGEST val_long
= unpack_long (type
, valaddr
);
471 if (TYPE_UNSIGNED (type
))
472 type
= builtin_type (gdbarch
)->builtin_true_unsigned_char
;
474 type
= builtin_type (gdbarch
)->builtin_true_char
;
476 value_print (value_from_longest (type
, val_long
), stream
, &opts
);
482 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
484 print_address (gdbarch
, addr
, stream
);
489 error (_("Undefined output format \"%c\"."), format
);
493 /* Specify default address for `x' command.
494 The `info lines' command uses this. */
497 set_next_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
499 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
501 next_gdbarch
= gdbarch
;
504 /* Make address available to the user as $_. */
505 set_internalvar (lookup_internalvar ("_"),
506 value_from_pointer (ptr_type
, addr
));
509 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
510 after LEADIN. Print nothing if no symbolic name is found nearby.
511 Optionally also print source file and line number, if available.
512 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
513 or to interpret it as a possible C++ name and convert it back to source
514 form. However note that DO_DEMANGLE can be overridden by the specific
515 settings of the demangle and asm_demangle variables. Returns
516 non-zero if anything was printed; zero otherwise. */
519 print_address_symbolic (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
520 struct ui_file
*stream
,
521 int do_demangle
, const char *leadin
)
524 char *filename
= NULL
;
529 /* Throw away both name and filename. */
530 struct cleanup
*cleanup_chain
= make_cleanup (free_current_contents
, &name
);
531 make_cleanup (free_current_contents
, &filename
);
533 if (build_address_symbolic (gdbarch
, addr
, do_demangle
, &name
, &offset
,
534 &filename
, &line
, &unmapped
))
536 do_cleanups (cleanup_chain
);
540 fputs_filtered (leadin
, stream
);
542 fputs_filtered ("<*", stream
);
544 fputs_filtered ("<", stream
);
545 fputs_filtered (name
, stream
);
547 fprintf_filtered (stream
, "+%u", (unsigned int) offset
);
549 /* Append source filename and line number if desired. Give specific
550 line # of this addr, if we have it; else line # of the nearest symbol. */
551 if (print_symbol_filename
&& filename
!= NULL
)
554 fprintf_filtered (stream
, " at %s:%d", filename
, line
);
556 fprintf_filtered (stream
, " in %s", filename
);
559 fputs_filtered ("*>", stream
);
561 fputs_filtered (">", stream
);
563 do_cleanups (cleanup_chain
);
567 /* Given an address ADDR return all the elements needed to print the
568 address in a symbolic form. NAME can be mangled or not depending
569 on DO_DEMANGLE (and also on the asm_demangle global variable,
570 manipulated via ''set print asm-demangle''). Return 0 in case of
571 success, when all the info in the OUT paramters is valid. Return 1
574 build_address_symbolic (struct gdbarch
*gdbarch
,
575 CORE_ADDR addr
, /* IN */
576 int do_demangle
, /* IN */
577 char **name
, /* OUT */
578 int *offset
, /* OUT */
579 char **filename
, /* OUT */
581 int *unmapped
) /* OUT */
583 struct bound_minimal_symbol msymbol
;
584 struct symbol
*symbol
;
585 CORE_ADDR name_location
= 0;
586 struct obj_section
*section
= NULL
;
587 const char *name_temp
= "";
589 /* Let's say it is mapped (not unmapped). */
592 /* Determine if the address is in an overlay, and whether it is
594 if (overlay_debugging
)
596 section
= find_pc_overlay (addr
);
597 if (pc_in_unmapped_range (addr
, section
))
600 addr
= overlay_mapped_address (addr
, section
);
604 /* First try to find the address in the symbol table, then
605 in the minsyms. Take the closest one. */
607 /* This is defective in the sense that it only finds text symbols. So
608 really this is kind of pointless--we should make sure that the
609 minimal symbols have everything we need (by changing that we could
610 save some memory, but for many debug format--ELF/DWARF or
611 anything/stabs--it would be inconvenient to eliminate those minimal
613 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
614 symbol
= find_pc_sect_function (addr
, section
);
618 /* If this is a function (i.e. a code address), strip out any
619 non-address bits. For instance, display a pointer to the
620 first instruction of a Thumb function as <function>; the
621 second instruction will be <function+2>, even though the
622 pointer is <function+3>. This matches the ISA behavior. */
623 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
625 name_location
= BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
));
626 if (do_demangle
|| asm_demangle
)
627 name_temp
= SYMBOL_PRINT_NAME (symbol
);
629 name_temp
= SYMBOL_LINKAGE_NAME (symbol
);
632 if (msymbol
.minsym
!= NULL
633 && MSYMBOL_HAS_SIZE (msymbol
.minsym
)
634 && MSYMBOL_SIZE (msymbol
.minsym
) == 0
635 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text
636 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text_gnu_ifunc
637 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_file_text
)
638 msymbol
.minsym
= NULL
;
640 if (msymbol
.minsym
!= NULL
)
642 if (BMSYMBOL_VALUE_ADDRESS (msymbol
) > name_location
|| symbol
== NULL
)
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 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_text
650 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_text_gnu_ifunc
651 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_text
652 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
653 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
655 /* The msymbol is closer to the address than the symbol;
656 use the msymbol instead. */
658 name_location
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
659 if (do_demangle
|| asm_demangle
)
660 name_temp
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
662 name_temp
= MSYMBOL_LINKAGE_NAME (msymbol
.minsym
);
665 if (symbol
== NULL
&& msymbol
.minsym
== NULL
)
668 /* If the nearest symbol is too far away, don't print anything symbolic. */
670 /* For when CORE_ADDR is larger than unsigned int, we do math in
671 CORE_ADDR. But when we detect unsigned wraparound in the
672 CORE_ADDR math, we ignore this test and print the offset,
673 because addr+max_symbolic_offset has wrapped through the end
674 of the address space back to the beginning, giving bogus comparison. */
675 if (addr
> name_location
+ max_symbolic_offset
676 && name_location
+ max_symbolic_offset
> name_location
)
679 *offset
= addr
- name_location
;
681 *name
= xstrdup (name_temp
);
683 if (print_symbol_filename
)
685 struct symtab_and_line sal
;
687 sal
= find_pc_sect_line (addr
, section
, 0);
691 *filename
= xstrdup (symtab_to_filename_for_display (sal
.symtab
));
699 /* Print address ADDR symbolically on STREAM.
700 First print it as a number. Then perhaps print
701 <SYMBOL + OFFSET> after the number. */
704 print_address (struct gdbarch
*gdbarch
,
705 CORE_ADDR addr
, struct ui_file
*stream
)
707 fputs_filtered (paddress (gdbarch
, addr
), stream
);
708 print_address_symbolic (gdbarch
, addr
, stream
, asm_demangle
, " ");
711 /* Return a prefix for instruction address:
712 "=> " for current instruction, else " ". */
715 pc_prefix (CORE_ADDR addr
)
717 if (has_stack_frames ())
719 struct frame_info
*frame
;
722 frame
= get_selected_frame (NULL
);
723 if (get_frame_pc_if_available (frame
, &pc
) && pc
== addr
)
729 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
730 controls whether to print the symbolic name "raw" or demangled.
731 Return non-zero if anything was printed; zero otherwise. */
734 print_address_demangle (const struct value_print_options
*opts
,
735 struct gdbarch
*gdbarch
, CORE_ADDR addr
,
736 struct ui_file
*stream
, int do_demangle
)
738 if (opts
->addressprint
)
740 fputs_filtered (paddress (gdbarch
, addr
), stream
);
741 print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, " ");
745 return print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, "");
751 /* Find the address of the instruction that is INST_COUNT instructions before
752 the instruction at ADDR.
753 Since some architectures have variable-length instructions, we can't just
754 simply subtract INST_COUNT * INSN_LEN from ADDR. Instead, we use line
755 number information to locate the nearest known instruction boundary,
756 and disassemble forward from there. If we go out of the symbol range
757 during disassembling, we return the lowest address we've got so far and
758 set the number of instructions read to INST_READ. */
761 find_instruction_backward (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
762 int inst_count
, int *inst_read
)
764 /* The vector PCS is used to store instruction addresses within
766 CORE_ADDR loop_start
, loop_end
, p
;
767 std::vector
<CORE_ADDR
> pcs
;
768 struct symtab_and_line sal
;
771 loop_start
= loop_end
= addr
;
773 /* In each iteration of the outer loop, we get a pc range that ends before
774 LOOP_START, then we count and store every instruction address of the range
775 iterated in the loop.
776 If the number of instructions counted reaches INST_COUNT, return the
777 stored address that is located INST_COUNT instructions back from ADDR.
778 If INST_COUNT is not reached, we subtract the number of counted
779 instructions from INST_COUNT, and go to the next iteration. */
783 sal
= find_pc_sect_line (loop_start
, NULL
, 1);
786 /* We reach here when line info is not available. In this case,
787 we print a message and just exit the loop. The return value
788 is calculated after the loop. */
789 printf_filtered (_("No line number information available "
792 print_address (gdbarch
, loop_start
- 1, gdb_stdout
);
793 printf_filtered ("\n");
797 loop_end
= loop_start
;
800 /* This loop pushes instruction addresses in the range from
801 LOOP_START to LOOP_END. */
802 for (p
= loop_start
; p
< loop_end
;)
805 p
+= gdb_insn_length (gdbarch
, p
);
808 inst_count
-= pcs
.size ();
809 *inst_read
+= pcs
.size ();
811 while (inst_count
> 0);
813 /* After the loop, the vector PCS has instruction addresses of the last
814 source line we processed, and INST_COUNT has a negative value.
815 We return the address at the index of -INST_COUNT in the vector for
817 Let's assume the following instruction addresses and run 'x/-4i 0x400e'.
827 find_instruction_backward is called with INST_COUNT = 4 and expected to
828 return 0x4001. When we reach here, INST_COUNT is set to -1 because
829 it was subtracted by 2 (from Line Y) and 3 (from Line X). The value
830 4001 is located at the index 1 of the last iterated line (= Line X),
831 which is simply calculated by -INST_COUNT.
832 The case when the length of PCS is 0 means that we reached an area for
833 which line info is not available. In such case, we return LOOP_START,
834 which was the lowest instruction address that had line info. */
835 p
= pcs
.size () > 0 ? pcs
[-inst_count
] : loop_start
;
837 /* INST_READ includes all instruction addresses in a pc range. Need to
838 exclude the beginning part up to the address we're returning. That
839 is, exclude {0x4000} in the example above. */
841 *inst_read
+= inst_count
;
846 /* Backward read LEN bytes of target memory from address MEMADDR + LEN,
847 placing the results in GDB's memory from MYADDR + LEN. Returns
848 a count of the bytes actually read. */
851 read_memory_backward (struct gdbarch
*gdbarch
,
852 CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
855 int nread
; /* Number of bytes actually read. */
857 /* First try a complete read. */
858 errcode
= target_read_memory (memaddr
, myaddr
, len
);
866 /* Loop, reading one byte at a time until we get as much as we can. */
869 for (nread
= 0; nread
< len
; ++nread
)
871 errcode
= target_read_memory (--memaddr
, --myaddr
, 1);
874 /* The read was unsuccessful, so exit the loop. */
875 printf_filtered (_("Cannot access memory at address %s\n"),
876 paddress (gdbarch
, memaddr
));
884 /* Returns true if X (which is LEN bytes wide) is the number zero. */
887 integer_is_zero (const gdb_byte
*x
, int len
)
891 while (i
< len
&& x
[i
] == 0)
896 /* Find the start address of a string in which ADDR is included.
897 Basically we search for '\0' and return the next address,
898 but if OPTIONS->PRINT_MAX is smaller than the length of a string,
899 we stop searching and return the address to print characters as many as
900 PRINT_MAX from the string. */
903 find_string_backward (struct gdbarch
*gdbarch
,
904 CORE_ADDR addr
, int count
, int char_size
,
905 const struct value_print_options
*options
,
906 int *strings_counted
)
908 const int chunk_size
= 0x20;
911 int chars_to_read
= chunk_size
;
912 int chars_counted
= 0;
913 int count_original
= count
;
914 CORE_ADDR string_start_addr
= addr
;
916 gdb_assert (char_size
== 1 || char_size
== 2 || char_size
== 4);
917 gdb::byte_vector
buffer (chars_to_read
* char_size
);
918 while (count
> 0 && read_error
== 0)
922 addr
-= chars_to_read
* char_size
;
923 chars_read
= read_memory_backward (gdbarch
, addr
, buffer
.data (),
924 chars_to_read
* char_size
);
925 chars_read
/= char_size
;
926 read_error
= (chars_read
== chars_to_read
) ? 0 : 1;
927 /* Searching for '\0' from the end of buffer in backward direction. */
928 for (i
= 0; i
< chars_read
&& count
> 0 ; ++i
, ++chars_counted
)
930 int offset
= (chars_to_read
- i
- 1) * char_size
;
932 if (integer_is_zero (&buffer
[offset
], char_size
)
933 || chars_counted
== options
->print_max
)
935 /* Found '\0' or reached print_max. As OFFSET is the offset to
936 '\0', we add CHAR_SIZE to return the start address of
939 string_start_addr
= addr
+ offset
+ char_size
;
945 /* Update STRINGS_COUNTED with the actual number of loaded strings. */
946 *strings_counted
= count_original
- count
;
950 /* In error case, STRING_START_ADDR is pointing to the string that
951 was last successfully loaded. Rewind the partially loaded string. */
952 string_start_addr
-= chars_counted
* char_size
;
955 return string_start_addr
;
958 /* Examine data at address ADDR in format FMT.
959 Fetch it from memory and print on gdb_stdout. */
962 do_examine (struct format_data fmt
, struct gdbarch
*gdbarch
, CORE_ADDR addr
)
967 struct type
*val_type
= NULL
;
970 struct value_print_options opts
;
971 int need_to_update_next_address
= 0;
972 CORE_ADDR addr_rewound
= 0;
977 next_gdbarch
= gdbarch
;
980 /* Instruction format implies fetch single bytes
981 regardless of the specified size.
982 The case of strings is handled in decode_format, only explicit
983 size operator are not changed to 'b'. */
989 /* Pick the appropriate size for an address. */
990 if (gdbarch_ptr_bit (next_gdbarch
) == 64)
992 else if (gdbarch_ptr_bit (next_gdbarch
) == 32)
994 else if (gdbarch_ptr_bit (next_gdbarch
) == 16)
997 /* Bad value for gdbarch_ptr_bit. */
998 internal_error (__FILE__
, __LINE__
,
999 _("failed internal consistency check"));
1003 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1004 else if (size
== 'h')
1005 val_type
= builtin_type (next_gdbarch
)->builtin_int16
;
1006 else if (size
== 'w')
1007 val_type
= builtin_type (next_gdbarch
)->builtin_int32
;
1008 else if (size
== 'g')
1009 val_type
= builtin_type (next_gdbarch
)->builtin_int64
;
1013 struct type
*char_type
= NULL
;
1015 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
1016 if type is not found. */
1018 char_type
= builtin_type (next_gdbarch
)->builtin_char16
;
1019 else if (size
== 'w')
1020 char_type
= builtin_type (next_gdbarch
)->builtin_char32
;
1022 val_type
= char_type
;
1025 if (size
!= '\0' && size
!= 'b')
1026 warning (_("Unable to display strings with "
1027 "size '%c', using 'b' instead."), size
);
1029 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1038 if (format
== 's' || format
== 'i')
1041 get_formatted_print_options (&opts
, format
);
1045 /* This is the negative repeat count case.
1046 We rewind the address based on the given repeat count and format,
1047 then examine memory from there in forward direction. */
1052 next_address
= find_instruction_backward (gdbarch
, addr
, count
,
1055 else if (format
== 's')
1057 next_address
= find_string_backward (gdbarch
, addr
, count
,
1058 TYPE_LENGTH (val_type
),
1063 next_address
= addr
- count
* TYPE_LENGTH (val_type
);
1066 /* The following call to print_formatted updates next_address in every
1067 iteration. In backward case, we store the start address here
1068 and update next_address with it before exiting the function. */
1069 addr_rewound
= (format
== 's'
1070 ? next_address
- TYPE_LENGTH (val_type
)
1072 need_to_update_next_address
= 1;
1075 /* Print as many objects as specified in COUNT, at most maxelts per line,
1076 with the address of the next one at the start of each line. */
1082 fputs_filtered (pc_prefix (next_address
), gdb_stdout
);
1083 print_address (next_gdbarch
, next_address
, gdb_stdout
);
1084 printf_filtered (":");
1089 printf_filtered ("\t");
1090 /* Note that print_formatted sets next_address for the next
1092 last_examine_address
= next_address
;
1094 /* The value to be displayed is not fetched greedily.
1095 Instead, to avoid the possibility of a fetched value not
1096 being used, its retrieval is delayed until the print code
1097 uses it. When examining an instruction stream, the
1098 disassembler will perform its own memory fetch using just
1099 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
1100 the disassembler be modified so that LAST_EXAMINE_VALUE
1101 is left with the byte sequence from the last complete
1102 instruction fetched from memory? */
1104 = release_value (value_at_lazy (val_type
, next_address
));
1106 print_formatted (last_examine_value
.get (), size
, &opts
, gdb_stdout
);
1108 /* Display any branch delay slots following the final insn. */
1109 if (format
== 'i' && count
== 1)
1110 count
+= branch_delay_insns
;
1112 printf_filtered ("\n");
1113 gdb_flush (gdb_stdout
);
1116 if (need_to_update_next_address
)
1117 next_address
= addr_rewound
;
1121 validate_format (struct format_data fmt
, const char *cmdname
)
1124 error (_("Size letters are meaningless in \"%s\" command."), cmdname
);
1126 error (_("Item count other than 1 is meaningless in \"%s\" command."),
1128 if (fmt
.format
== 'i')
1129 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
1130 fmt
.format
, cmdname
);
1133 /* Parse print command format string into *FMTP and update *EXPP.
1134 CMDNAME should name the current command. */
1137 print_command_parse_format (const char **expp
, const char *cmdname
,
1138 struct format_data
*fmtp
)
1140 const char *exp
= *expp
;
1142 if (exp
&& *exp
== '/')
1145 *fmtp
= decode_format (&exp
, last_format
, 0);
1146 validate_format (*fmtp
, cmdname
);
1147 last_format
= fmtp
->format
;
1160 /* Print VAL to console according to *FMTP, including recording it to
1164 print_value (struct value
*val
, const struct format_data
*fmtp
)
1166 struct value_print_options opts
;
1167 int histindex
= record_latest_value (val
);
1169 annotate_value_history_begin (histindex
, value_type (val
));
1171 printf_filtered ("$%d = ", histindex
);
1173 annotate_value_history_value ();
1175 get_formatted_print_options (&opts
, fmtp
->format
);
1176 opts
.raw
= fmtp
->raw
;
1178 print_formatted (val
, fmtp
->size
, &opts
, gdb_stdout
);
1179 printf_filtered ("\n");
1181 annotate_value_history_end ();
1184 /* Evaluate string EXP as an expression in the current language and
1185 print the resulting value. EXP may contain a format specifier as the
1186 first argument ("/x myvar" for example, to print myvar in hex). */
1189 print_command_1 (const char *exp
, int voidprint
)
1192 struct format_data fmt
;
1194 print_command_parse_format (&exp
, "print", &fmt
);
1198 expression_up expr
= parse_expression (exp
);
1199 val
= evaluate_expression (expr
.get ());
1202 val
= access_value_history (0);
1204 if (voidprint
|| (val
&& value_type (val
) &&
1205 TYPE_CODE (value_type (val
)) != TYPE_CODE_VOID
))
1206 print_value (val
, &fmt
);
1210 print_command (const char *exp
, int from_tty
)
1212 print_command_1 (exp
, 1);
1215 /* Same as print, except it doesn't print void results. */
1217 call_command (const char *exp
, int from_tty
)
1219 print_command_1 (exp
, 0);
1222 /* Implementation of the "output" command. */
1225 output_command (const char *exp
, int from_tty
)
1229 struct format_data fmt
;
1230 struct value_print_options opts
;
1235 if (exp
&& *exp
== '/')
1238 fmt
= decode_format (&exp
, 0, 0);
1239 validate_format (fmt
, "output");
1240 format
= fmt
.format
;
1243 expression_up expr
= parse_expression (exp
);
1245 val
= evaluate_expression (expr
.get ());
1247 annotate_value_begin (value_type (val
));
1249 get_formatted_print_options (&opts
, format
);
1251 print_formatted (val
, fmt
.size
, &opts
, gdb_stdout
);
1253 annotate_value_end ();
1256 gdb_flush (gdb_stdout
);
1260 set_command (const char *exp
, int from_tty
)
1262 expression_up expr
= parse_expression (exp
);
1264 if (expr
->nelts
>= 1)
1265 switch (expr
->elts
[0].opcode
)
1267 case UNOP_PREINCREMENT
:
1268 case UNOP_POSTINCREMENT
:
1269 case UNOP_PREDECREMENT
:
1270 case UNOP_POSTDECREMENT
:
1272 case BINOP_ASSIGN_MODIFY
:
1277 (_("Expression is not an assignment (and might have no effect)"));
1280 evaluate_expression (expr
.get ());
1284 info_symbol_command (const char *arg
, int from_tty
)
1286 struct minimal_symbol
*msymbol
;
1287 struct objfile
*objfile
;
1288 struct obj_section
*osect
;
1289 CORE_ADDR addr
, sect_addr
;
1291 unsigned int offset
;
1294 error_no_arg (_("address"));
1296 addr
= parse_and_eval_address (arg
);
1297 ALL_OBJSECTIONS (objfile
, osect
)
1299 /* Only process each object file once, even if there's a separate
1301 if (objfile
->separate_debug_objfile_backlink
)
1304 sect_addr
= overlay_mapped_address (addr
, osect
);
1306 if (obj_section_addr (osect
) <= sect_addr
1307 && sect_addr
< obj_section_endaddr (osect
)
1309 = lookup_minimal_symbol_by_pc_section (sect_addr
, osect
).minsym
))
1311 const char *obj_name
, *mapped
, *sec_name
, *msym_name
;
1312 const char *loc_string
;
1313 struct cleanup
*old_chain
;
1316 offset
= sect_addr
- MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
);
1317 mapped
= section_is_mapped (osect
) ? _("mapped") : _("unmapped");
1318 sec_name
= osect
->the_bfd_section
->name
;
1319 msym_name
= MSYMBOL_PRINT_NAME (msymbol
);
1321 /* Don't print the offset if it is zero.
1322 We assume there's no need to handle i18n of "sym + offset". */
1323 std::string string_holder
;
1326 string_holder
= string_printf ("%s + %u", msym_name
, offset
);
1327 loc_string
= string_holder
.c_str ();
1330 loc_string
= msym_name
;
1332 gdb_assert (osect
->objfile
&& objfile_name (osect
->objfile
));
1333 obj_name
= objfile_name (osect
->objfile
);
1335 if (MULTI_OBJFILE_P ())
1336 if (pc_in_unmapped_range (addr
, osect
))
1337 if (section_is_overlay (osect
))
1338 printf_filtered (_("%s in load address range of "
1339 "%s overlay section %s of %s\n"),
1340 loc_string
, mapped
, sec_name
, obj_name
);
1342 printf_filtered (_("%s in load address range of "
1343 "section %s of %s\n"),
1344 loc_string
, sec_name
, obj_name
);
1346 if (section_is_overlay (osect
))
1347 printf_filtered (_("%s in %s overlay section %s of %s\n"),
1348 loc_string
, mapped
, sec_name
, obj_name
);
1350 printf_filtered (_("%s in section %s of %s\n"),
1351 loc_string
, sec_name
, obj_name
);
1353 if (pc_in_unmapped_range (addr
, osect
))
1354 if (section_is_overlay (osect
))
1355 printf_filtered (_("%s in load address range of %s overlay "
1357 loc_string
, mapped
, sec_name
);
1359 printf_filtered (_("%s in load address range of section %s\n"),
1360 loc_string
, sec_name
);
1362 if (section_is_overlay (osect
))
1363 printf_filtered (_("%s in %s overlay section %s\n"),
1364 loc_string
, mapped
, sec_name
);
1366 printf_filtered (_("%s in section %s\n"),
1367 loc_string
, sec_name
);
1371 printf_filtered (_("No symbol matches %s.\n"), arg
);
1375 info_address_command (const char *exp
, int from_tty
)
1377 struct gdbarch
*gdbarch
;
1380 struct bound_minimal_symbol msymbol
;
1382 struct obj_section
*section
;
1383 CORE_ADDR load_addr
, context_pc
= 0;
1384 struct field_of_this_result is_a_field_of_this
;
1387 error (_("Argument required."));
1389 sym
= lookup_symbol (exp
, get_selected_block (&context_pc
), VAR_DOMAIN
,
1390 &is_a_field_of_this
).symbol
;
1393 if (is_a_field_of_this
.type
!= NULL
)
1395 printf_filtered ("Symbol \"");
1396 fprintf_symbol_filtered (gdb_stdout
, exp
,
1397 current_language
->la_language
, DMGL_ANSI
);
1398 printf_filtered ("\" is a field of the local class variable ");
1399 if (current_language
->la_language
== language_objc
)
1400 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1402 printf_filtered ("`this'\n");
1406 msymbol
= lookup_bound_minimal_symbol (exp
);
1408 if (msymbol
.minsym
!= NULL
)
1410 struct objfile
*objfile
= msymbol
.objfile
;
1412 gdbarch
= get_objfile_arch (objfile
);
1413 load_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
1415 printf_filtered ("Symbol \"");
1416 fprintf_symbol_filtered (gdb_stdout
, exp
,
1417 current_language
->la_language
, DMGL_ANSI
);
1418 printf_filtered ("\" is at ");
1419 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1420 printf_filtered (" in a file compiled without debugging");
1421 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
1422 if (section_is_overlay (section
))
1424 load_addr
= overlay_unmapped_address (load_addr
, section
);
1425 printf_filtered (",\n -- loaded at ");
1426 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1427 printf_filtered (" in overlay section %s",
1428 section
->the_bfd_section
->name
);
1430 printf_filtered (".\n");
1433 error (_("No symbol \"%s\" in current context."), exp
);
1437 printf_filtered ("Symbol \"");
1438 fprintf_symbol_filtered (gdb_stdout
, SYMBOL_PRINT_NAME (sym
),
1439 current_language
->la_language
, DMGL_ANSI
);
1440 printf_filtered ("\" is ");
1441 val
= SYMBOL_VALUE (sym
);
1442 if (SYMBOL_OBJFILE_OWNED (sym
))
1443 section
= SYMBOL_OBJ_SECTION (symbol_objfile (sym
), sym
);
1446 gdbarch
= symbol_arch (sym
);
1448 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
1450 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, context_pc
,
1452 printf_filtered (".\n");
1456 switch (SYMBOL_CLASS (sym
))
1459 case LOC_CONST_BYTES
:
1460 printf_filtered ("constant");
1464 printf_filtered ("a label at address ");
1465 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1466 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1467 if (section_is_overlay (section
))
1469 load_addr
= overlay_unmapped_address (load_addr
, section
);
1470 printf_filtered (",\n -- loaded at ");
1471 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1472 printf_filtered (" in overlay section %s",
1473 section
->the_bfd_section
->name
);
1478 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
1481 /* GDBARCH is the architecture associated with the objfile the symbol
1482 is defined in; the target architecture may be different, and may
1483 provide additional registers. However, we do not know the target
1484 architecture at this point. We assume the objfile architecture
1485 will contain all the standard registers that occur in debug info
1487 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1489 if (SYMBOL_IS_ARGUMENT (sym
))
1490 printf_filtered (_("an argument in register %s"),
1491 gdbarch_register_name (gdbarch
, regno
));
1493 printf_filtered (_("a variable in register %s"),
1494 gdbarch_register_name (gdbarch
, regno
));
1498 printf_filtered (_("static storage at address "));
1499 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1500 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1501 if (section_is_overlay (section
))
1503 load_addr
= overlay_unmapped_address (load_addr
, section
);
1504 printf_filtered (_(",\n -- loaded at "));
1505 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1506 printf_filtered (_(" in overlay section %s"),
1507 section
->the_bfd_section
->name
);
1511 case LOC_REGPARM_ADDR
:
1512 /* Note comment at LOC_REGISTER. */
1513 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1514 printf_filtered (_("address of an argument in register %s"),
1515 gdbarch_register_name (gdbarch
, regno
));
1519 printf_filtered (_("an argument at offset %ld"), val
);
1523 printf_filtered (_("a local variable at frame offset %ld"), val
);
1527 printf_filtered (_("a reference argument at offset %ld"), val
);
1531 printf_filtered (_("a typedef"));
1535 printf_filtered (_("a function at address "));
1536 load_addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1537 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1538 if (section_is_overlay (section
))
1540 load_addr
= overlay_unmapped_address (load_addr
, section
);
1541 printf_filtered (_(",\n -- loaded at "));
1542 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1543 printf_filtered (_(" in overlay section %s"),
1544 section
->the_bfd_section
->name
);
1548 case LOC_UNRESOLVED
:
1550 struct bound_minimal_symbol msym
;
1552 msym
= lookup_bound_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
));
1553 if (msym
.minsym
== NULL
)
1554 printf_filtered ("unresolved");
1557 section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
1560 && (section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
1562 load_addr
= MSYMBOL_VALUE_RAW_ADDRESS (msym
.minsym
);
1563 printf_filtered (_("a thread-local variable at offset %s "
1564 "in the thread-local storage for `%s'"),
1565 paddress (gdbarch
, load_addr
),
1566 objfile_name (section
->objfile
));
1570 load_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
1571 printf_filtered (_("static storage at address "));
1572 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1573 if (section_is_overlay (section
))
1575 load_addr
= overlay_unmapped_address (load_addr
, section
);
1576 printf_filtered (_(",\n -- loaded at "));
1577 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1578 printf_filtered (_(" in overlay section %s"),
1579 section
->the_bfd_section
->name
);
1586 case LOC_OPTIMIZED_OUT
:
1587 printf_filtered (_("optimized out"));
1591 printf_filtered (_("of unknown (botched) type"));
1594 printf_filtered (".\n");
1599 x_command (const char *exp
, int from_tty
)
1601 struct format_data fmt
;
1604 fmt
.format
= last_format
? last_format
: 'x';
1605 fmt
.size
= last_size
;
1609 /* If there is no expression and no format, use the most recent
1611 if (exp
== nullptr && last_count
> 0)
1612 fmt
.count
= last_count
;
1614 if (exp
&& *exp
== '/')
1616 const char *tmp
= exp
+ 1;
1618 fmt
= decode_format (&tmp
, last_format
, last_size
);
1622 last_count
= fmt
.count
;
1624 /* If we have an expression, evaluate it and use it as the address. */
1626 if (exp
!= 0 && *exp
!= 0)
1628 expression_up expr
= parse_expression (exp
);
1629 /* Cause expression not to be there any more if this command is
1630 repeated with Newline. But don't clobber a user-defined
1631 command's definition. */
1633 set_repeat_arguments ("");
1634 val
= evaluate_expression (expr
.get ());
1635 if (TYPE_IS_REFERENCE (value_type (val
)))
1636 val
= coerce_ref (val
);
1637 /* In rvalue contexts, such as this, functions are coerced into
1638 pointers to functions. This makes "x/i main" work. */
1639 if (/* last_format == 'i' && */
1640 TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
1641 && VALUE_LVAL (val
) == lval_memory
)
1642 next_address
= value_address (val
);
1644 next_address
= value_as_address (val
);
1646 next_gdbarch
= expr
->gdbarch
;
1650 error_no_arg (_("starting display address"));
1652 do_examine (fmt
, next_gdbarch
, next_address
);
1654 /* If the examine succeeds, we remember its size and format for next
1655 time. Set last_size to 'b' for strings. */
1656 if (fmt
.format
== 's')
1659 last_size
= fmt
.size
;
1660 last_format
= fmt
.format
;
1662 /* Set a couple of internal variables if appropriate. */
1663 if (last_examine_value
!= nullptr)
1665 /* Make last address examined available to the user as $_. Use
1666 the correct pointer type. */
1667 struct type
*pointer_type
1668 = lookup_pointer_type (value_type (last_examine_value
.get ()));
1669 set_internalvar (lookup_internalvar ("_"),
1670 value_from_pointer (pointer_type
,
1671 last_examine_address
));
1673 /* Make contents of last address examined available to the user
1674 as $__. If the last value has not been fetched from memory
1675 then don't fetch it now; instead mark it by voiding the $__
1677 if (value_lazy (last_examine_value
.get ()))
1678 clear_internalvar (lookup_internalvar ("__"));
1680 set_internalvar (lookup_internalvar ("__"), last_examine_value
.get ());
1685 /* Add an expression to the auto-display chain.
1686 Specify the expression. */
1689 display_command (const char *arg
, int from_tty
)
1691 struct format_data fmt
;
1692 struct display
*newobj
;
1693 const char *exp
= arg
;
1704 fmt
= decode_format (&exp
, 0, 0);
1705 if (fmt
.size
&& fmt
.format
== 0)
1707 if (fmt
.format
== 'i' || fmt
.format
== 's')
1718 innermost_block
.reset ();
1719 expression_up expr
= parse_expression (exp
);
1721 newobj
= new display ();
1723 newobj
->exp_string
= xstrdup (exp
);
1724 newobj
->exp
= std::move (expr
);
1725 newobj
->block
= innermost_block
.block ();
1726 newobj
->pspace
= current_program_space
;
1727 newobj
->number
= ++display_number
;
1728 newobj
->format
= fmt
;
1729 newobj
->enabled_p
= 1;
1730 newobj
->next
= NULL
;
1732 if (display_chain
== NULL
)
1733 display_chain
= newobj
;
1736 struct display
*last
;
1738 for (last
= display_chain
; last
->next
!= NULL
; last
= last
->next
)
1740 last
->next
= newobj
;
1744 do_one_display (newobj
);
1750 free_display (struct display
*d
)
1752 xfree (d
->exp_string
);
1756 /* Clear out the display_chain. Done when new symtabs are loaded,
1757 since this invalidates the types stored in many expressions. */
1760 clear_displays (void)
1764 while ((d
= display_chain
) != NULL
)
1766 display_chain
= d
->next
;
1771 /* Delete the auto-display DISPLAY. */
1774 delete_display (struct display
*display
)
1778 gdb_assert (display
!= NULL
);
1780 if (display_chain
== display
)
1781 display_chain
= display
->next
;
1784 if (d
->next
== display
)
1786 d
->next
= display
->next
;
1790 free_display (display
);
1793 /* Call FUNCTION on each of the displays whose numbers are given in
1794 ARGS. DATA is passed unmodified to FUNCTION. */
1797 map_display_numbers (const char *args
,
1798 void (*function
) (struct display
*,
1805 error_no_arg (_("one or more display numbers"));
1807 number_or_range_parser
parser (args
);
1809 while (!parser
.finished ())
1811 const char *p
= parser
.cur_tok ();
1813 num
= parser
.get_number ();
1815 warning (_("bad display number at or near '%s'"), p
);
1818 struct display
*d
, *tmp
;
1820 ALL_DISPLAYS_SAFE (d
, tmp
)
1821 if (d
->number
== num
)
1824 printf_unfiltered (_("No display number %d.\n"), num
);
1831 /* Callback for map_display_numbers, that deletes a display. */
1834 do_delete_display (struct display
*d
, void *data
)
1839 /* "undisplay" command. */
1842 undisplay_command (const char *args
, int from_tty
)
1846 if (query (_("Delete all auto-display expressions? ")))
1852 map_display_numbers (args
, do_delete_display
, NULL
);
1856 /* Display a single auto-display.
1857 Do nothing if the display cannot be printed in the current context,
1858 or if the display is disabled. */
1861 do_one_display (struct display
*d
)
1863 int within_current_scope
;
1865 if (d
->enabled_p
== 0)
1868 /* The expression carries the architecture that was used at parse time.
1869 This is a problem if the expression depends on architecture features
1870 (e.g. register numbers), and the current architecture is now different.
1871 For example, a display statement like "display/i $pc" is expected to
1872 display the PC register of the current architecture, not the arch at
1873 the time the display command was given. Therefore, we re-parse the
1874 expression if the current architecture has changed. */
1875 if (d
->exp
!= NULL
&& d
->exp
->gdbarch
!= get_current_arch ())
1886 innermost_block
.reset ();
1887 d
->exp
= parse_expression (d
->exp_string
);
1888 d
->block
= innermost_block
.block ();
1890 CATCH (ex
, RETURN_MASK_ALL
)
1892 /* Can't re-parse the expression. Disable this display item. */
1894 warning (_("Unable to display \"%s\": %s"),
1895 d
->exp_string
, ex
.message
);
1903 if (d
->pspace
== current_program_space
)
1904 within_current_scope
= contained_in (get_selected_block (0), d
->block
);
1906 within_current_scope
= 0;
1909 within_current_scope
= 1;
1910 if (!within_current_scope
)
1913 scoped_restore save_display_number
1914 = make_scoped_restore (¤t_display_number
, d
->number
);
1916 annotate_display_begin ();
1917 printf_filtered ("%d", d
->number
);
1918 annotate_display_number_end ();
1919 printf_filtered (": ");
1923 annotate_display_format ();
1925 printf_filtered ("x/");
1926 if (d
->format
.count
!= 1)
1927 printf_filtered ("%d", d
->format
.count
);
1928 printf_filtered ("%c", d
->format
.format
);
1929 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1930 printf_filtered ("%c", d
->format
.size
);
1931 printf_filtered (" ");
1933 annotate_display_expression ();
1935 puts_filtered (d
->exp_string
);
1936 annotate_display_expression_end ();
1938 if (d
->format
.count
!= 1 || d
->format
.format
== 'i')
1939 printf_filtered ("\n");
1941 printf_filtered (" ");
1943 annotate_display_value ();
1950 val
= evaluate_expression (d
->exp
.get ());
1951 addr
= value_as_address (val
);
1952 if (d
->format
.format
== 'i')
1953 addr
= gdbarch_addr_bits_remove (d
->exp
->gdbarch
, addr
);
1954 do_examine (d
->format
, d
->exp
->gdbarch
, addr
);
1956 CATCH (ex
, RETURN_MASK_ERROR
)
1958 fprintf_filtered (gdb_stdout
, _("<error: %s>\n"), ex
.message
);
1964 struct value_print_options opts
;
1966 annotate_display_format ();
1968 if (d
->format
.format
)
1969 printf_filtered ("/%c ", d
->format
.format
);
1971 annotate_display_expression ();
1973 puts_filtered (d
->exp_string
);
1974 annotate_display_expression_end ();
1976 printf_filtered (" = ");
1978 annotate_display_expression ();
1980 get_formatted_print_options (&opts
, d
->format
.format
);
1981 opts
.raw
= d
->format
.raw
;
1987 val
= evaluate_expression (d
->exp
.get ());
1988 print_formatted (val
, d
->format
.size
, &opts
, gdb_stdout
);
1990 CATCH (ex
, RETURN_MASK_ERROR
)
1992 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
1996 printf_filtered ("\n");
1999 annotate_display_end ();
2001 gdb_flush (gdb_stdout
);
2004 /* Display all of the values on the auto-display chain which can be
2005 evaluated in the current scope. */
2012 for (d
= display_chain
; d
; d
= d
->next
)
2016 /* Delete the auto-display which we were in the process of displaying.
2017 This is done when there is an error or a signal. */
2020 disable_display (int num
)
2024 for (d
= display_chain
; d
; d
= d
->next
)
2025 if (d
->number
== num
)
2030 printf_unfiltered (_("No display number %d.\n"), num
);
2034 disable_current_display (void)
2036 if (current_display_number
>= 0)
2038 disable_display (current_display_number
);
2039 fprintf_unfiltered (gdb_stderr
,
2040 _("Disabling display %d to "
2041 "avoid infinite recursion.\n"),
2042 current_display_number
);
2044 current_display_number
= -1;
2048 info_display_command (const char *ignore
, int from_tty
)
2053 printf_unfiltered (_("There are no auto-display expressions now.\n"));
2055 printf_filtered (_("Auto-display expressions now in effect:\n\
2056 Num Enb Expression\n"));
2058 for (d
= display_chain
; d
; d
= d
->next
)
2060 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
2062 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
2064 else if (d
->format
.format
)
2065 printf_filtered ("/%c ", d
->format
.format
);
2066 puts_filtered (d
->exp_string
);
2067 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
))
2068 printf_filtered (_(" (cannot be evaluated in the current context)"));
2069 printf_filtered ("\n");
2070 gdb_flush (gdb_stdout
);
2074 /* Callback fo map_display_numbers, that enables or disables the
2075 passed in display D. */
2078 do_enable_disable_display (struct display
*d
, void *data
)
2080 d
->enabled_p
= *(int *) data
;
2083 /* Implamentation of both the "disable display" and "enable display"
2084 commands. ENABLE decides what to do. */
2087 enable_disable_display_command (const char *args
, int from_tty
, int enable
)
2094 d
->enabled_p
= enable
;
2098 map_display_numbers (args
, do_enable_disable_display
, &enable
);
2101 /* The "enable display" command. */
2104 enable_display_command (const char *args
, int from_tty
)
2106 enable_disable_display_command (args
, from_tty
, 1);
2109 /* The "disable display" command. */
2112 disable_display_command (const char *args
, int from_tty
)
2114 enable_disable_display_command (args
, from_tty
, 0);
2117 /* display_chain items point to blocks and expressions. Some expressions in
2118 turn may point to symbols.
2119 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
2120 obstack_free'd when a shared library is unloaded.
2121 Clear pointers that are about to become dangling.
2122 Both .exp and .block fields will be restored next time we need to display
2123 an item by re-parsing .exp_string field in the new execution context. */
2126 clear_dangling_display_expressions (struct objfile
*objfile
)
2129 struct program_space
*pspace
;
2131 /* With no symbol file we cannot have a block or expression from it. */
2132 if (objfile
== NULL
)
2134 pspace
= objfile
->pspace
;
2135 if (objfile
->separate_debug_objfile_backlink
)
2137 objfile
= objfile
->separate_debug_objfile_backlink
;
2138 gdb_assert (objfile
->pspace
== pspace
);
2141 for (d
= display_chain
; d
!= NULL
; d
= d
->next
)
2143 if (d
->pspace
!= pspace
)
2146 if (lookup_objfile_from_block (d
->block
) == objfile
2147 || (d
->exp
!= NULL
&& exp_uses_objfile (d
->exp
.get (), objfile
)))
2156 /* Print the value in stack frame FRAME of a variable specified by a
2157 struct symbol. NAME is the name to print; if NULL then VAR's print
2158 name will be used. STREAM is the ui_file on which to print the
2159 value. INDENT specifies the number of indent levels to print
2160 before printing the variable name.
2162 This function invalidates FRAME. */
2165 print_variable_and_value (const char *name
, struct symbol
*var
,
2166 struct frame_info
*frame
,
2167 struct ui_file
*stream
, int indent
)
2171 name
= SYMBOL_PRINT_NAME (var
);
2173 fprintf_filtered (stream
, "%s%s = ", n_spaces (2 * indent
), name
);
2177 struct value_print_options opts
;
2179 /* READ_VAR_VALUE needs a block in order to deal with non-local
2180 references (i.e. to handle nested functions). In this context, we
2181 print variables that are local to this frame, so we can avoid passing
2183 val
= read_var_value (var
, NULL
, frame
);
2184 get_user_print_options (&opts
);
2186 common_val_print (val
, stream
, indent
, &opts
, current_language
);
2188 /* common_val_print invalidates FRAME when a pretty printer calls inferior
2192 CATCH (except
, RETURN_MASK_ERROR
)
2194 fprintf_filtered(stream
, "<error reading variable %s (%s)>", name
,
2199 fprintf_filtered (stream
, "\n");
2202 /* Subroutine of ui_printf to simplify it.
2203 Print VALUE to STREAM using FORMAT.
2204 VALUE is a C-style string on the target. */
2207 printf_c_string (struct ui_file
*stream
, const char *format
,
2208 struct value
*value
)
2214 tem
= value_as_address (value
);
2217 fprintf_filtered (stream
, format
, "(null)");
2221 /* This is a %s argument. Find the length of the string. */
2227 read_memory (tem
+ j
, &c
, 1);
2232 /* Copy the string contents into a string inside GDB. */
2233 str
= (gdb_byte
*) alloca (j
+ 1);
2235 read_memory (tem
, str
, j
);
2238 fprintf_filtered (stream
, format
, (char *) str
);
2241 /* Subroutine of ui_printf to simplify it.
2242 Print VALUE to STREAM using FORMAT.
2243 VALUE is a wide C-style string on the target. */
2246 printf_wide_c_string (struct ui_file
*stream
, const char *format
,
2247 struct value
*value
)
2252 struct gdbarch
*gdbarch
= get_type_arch (value_type (value
));
2253 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2254 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2255 "wchar_t", NULL
, 0);
2256 int wcwidth
= TYPE_LENGTH (wctype
);
2257 gdb_byte
*buf
= (gdb_byte
*) alloca (wcwidth
);
2259 tem
= value_as_address (value
);
2262 fprintf_filtered (stream
, format
, "(null)");
2266 /* This is a %s argument. Find the length of the string. */
2267 for (j
= 0;; j
+= wcwidth
)
2270 read_memory (tem
+ j
, buf
, wcwidth
);
2271 if (extract_unsigned_integer (buf
, wcwidth
, byte_order
) == 0)
2275 /* Copy the string contents into a string inside GDB. */
2276 str
= (gdb_byte
*) alloca (j
+ wcwidth
);
2278 read_memory (tem
, str
, j
);
2279 memset (&str
[j
], 0, wcwidth
);
2281 auto_obstack output
;
2283 convert_between_encodings (target_wide_charset (gdbarch
),
2286 &output
, translit_char
);
2287 obstack_grow_str0 (&output
, "");
2289 fprintf_filtered (stream
, format
, obstack_base (&output
));
2292 /* Subroutine of ui_printf to simplify it.
2293 Print VALUE, a floating point value, to STREAM using FORMAT. */
2296 printf_floating (struct ui_file
*stream
, const char *format
,
2297 struct value
*value
, enum argclass argclass
)
2299 /* Parameter data. */
2300 struct type
*param_type
= value_type (value
);
2301 struct gdbarch
*gdbarch
= get_type_arch (param_type
);
2302 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2304 /* Determine target type corresponding to the format string. */
2305 struct type
*fmt_type
;
2309 fmt_type
= builtin_type (gdbarch
)->builtin_double
;
2311 case long_double_arg
:
2312 fmt_type
= builtin_type (gdbarch
)->builtin_long_double
;
2314 case dec32float_arg
:
2315 fmt_type
= builtin_type (gdbarch
)->builtin_decfloat
;
2317 case dec64float_arg
:
2318 fmt_type
= builtin_type (gdbarch
)->builtin_decdouble
;
2320 case dec128float_arg
:
2321 fmt_type
= builtin_type (gdbarch
)->builtin_declong
;
2324 gdb_assert_not_reached ("unexpected argument class");
2327 /* To match the traditional GDB behavior, the conversion is
2328 done differently depending on the type of the parameter:
2330 - if the parameter has floating-point type, it's value
2331 is converted to the target type;
2333 - otherwise, if the parameter has a type that is of the
2334 same size as a built-in floating-point type, the value
2335 bytes are interpreted as if they were of that type, and
2336 then converted to the target type (this is not done for
2337 decimal floating-point argument classes);
2339 - otherwise, if the source value has an integer value,
2340 it's value is converted to the target type;
2342 - otherwise, an error is raised.
2344 In either case, the result of the conversion is a byte buffer
2345 formatted in the target format for the target type. */
2347 if (TYPE_CODE (fmt_type
) == TYPE_CODE_FLT
)
2349 param_type
= float_type_from_length (param_type
);
2350 if (param_type
!= value_type (value
))
2351 value
= value_from_contents (param_type
, value_contents (value
));
2354 value
= value_cast (fmt_type
, value
);
2356 /* Convert the value to a string and print it. */
2358 = target_float_to_string (value_contents (value
), fmt_type
, format
);
2359 fputs_filtered (str
.c_str (), stream
);
2362 /* Subroutine of ui_printf to simplify it.
2363 Print VALUE, a target pointer, to STREAM using FORMAT. */
2366 printf_pointer (struct ui_file
*stream
, const char *format
,
2367 struct value
*value
)
2369 /* We avoid the host's %p because pointers are too
2370 likely to be the wrong size. The only interesting
2371 modifier for %p is a width; extract that, and then
2372 handle %p as glibc would: %#x or a literal "(nil)". */
2376 #ifdef PRINTF_HAS_LONG_LONG
2377 long long val
= value_as_long (value
);
2379 long val
= value_as_long (value
);
2382 fmt
= (char *) alloca (strlen (format
) + 5);
2384 /* Copy up to the leading %. */
2389 int is_percent
= (*p
== '%');
2404 /* Copy any width or flags. Only the "-" flag is valid for pointers
2405 -- see the format_pieces constructor. */
2406 while (*p
== '-' || (*p
>= '0' && *p
< '9'))
2409 gdb_assert (*p
== 'p' && *(p
+ 1) == '\0');
2412 #ifdef PRINTF_HAS_LONG_LONG
2418 fprintf_filtered (stream
, fmt
, val
);
2424 fprintf_filtered (stream
, fmt
, "(nil)");
2428 /* printf "printf format string" ARG to STREAM. */
2431 ui_printf (const char *arg
, struct ui_file
*stream
)
2433 const char *s
= arg
;
2434 std::vector
<struct value
*> val_args
;
2437 error_no_arg (_("format-control string and values to print"));
2439 s
= skip_spaces (s
);
2441 /* A format string should follow, enveloped in double quotes. */
2443 error (_("Bad format string, missing '\"'."));
2445 format_pieces
fpieces (&s
);
2448 error (_("Bad format string, non-terminated '\"'."));
2450 s
= skip_spaces (s
);
2452 if (*s
!= ',' && *s
!= 0)
2453 error (_("Invalid argument syntax"));
2457 s
= skip_spaces (s
);
2462 const char *current_substring
;
2465 for (auto &&piece
: fpieces
)
2466 if (piece
.argclass
!= literal_piece
)
2469 /* Now, parse all arguments and evaluate them.
2470 Store the VALUEs in VAL_ARGS. */
2477 val_args
.push_back (parse_to_comma_and_eval (&s1
));
2484 if (val_args
.size () != nargs_wanted
)
2485 error (_("Wrong number of arguments for specified format-string"));
2487 /* Now actually print them. */
2489 for (auto &&piece
: fpieces
)
2491 current_substring
= piece
.string
;
2492 switch (piece
.argclass
)
2495 printf_c_string (stream
, current_substring
, val_args
[i
]);
2497 case wide_string_arg
:
2498 printf_wide_c_string (stream
, current_substring
, val_args
[i
]);
2502 struct gdbarch
*gdbarch
2503 = get_type_arch (value_type (val_args
[i
]));
2504 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2505 "wchar_t", NULL
, 0);
2506 struct type
*valtype
;
2507 const gdb_byte
*bytes
;
2509 valtype
= value_type (val_args
[i
]);
2510 if (TYPE_LENGTH (valtype
) != TYPE_LENGTH (wctype
)
2511 || TYPE_CODE (valtype
) != TYPE_CODE_INT
)
2512 error (_("expected wchar_t argument for %%lc"));
2514 bytes
= value_contents (val_args
[i
]);
2516 auto_obstack output
;
2518 convert_between_encodings (target_wide_charset (gdbarch
),
2520 bytes
, TYPE_LENGTH (valtype
),
2521 TYPE_LENGTH (valtype
),
2522 &output
, translit_char
);
2523 obstack_grow_str0 (&output
, "");
2525 fprintf_filtered (stream
, current_substring
,
2526 obstack_base (&output
));
2530 #ifdef PRINTF_HAS_LONG_LONG
2532 long long val
= value_as_long (val_args
[i
]);
2534 fprintf_filtered (stream
, current_substring
, val
);
2538 error (_("long long not supported in printf"));
2542 int val
= value_as_long (val_args
[i
]);
2544 fprintf_filtered (stream
, current_substring
, val
);
2549 long val
= value_as_long (val_args
[i
]);
2551 fprintf_filtered (stream
, current_substring
, val
);
2554 /* Handles floating-point values. */
2556 case long_double_arg
:
2557 case dec32float_arg
:
2558 case dec64float_arg
:
2559 case dec128float_arg
:
2560 printf_floating (stream
, current_substring
, val_args
[i
],
2564 printf_pointer (stream
, current_substring
, val_args
[i
]);
2567 /* Print a portion of the format string that has no
2568 directives. Note that this will not include any
2569 ordinary %-specs, but it might include "%%". That is
2570 why we use printf_filtered and not puts_filtered here.
2571 Also, we pass a dummy argument because some platforms
2572 have modified GCC to include -Wformat-security by
2573 default, which will warn here if there is no
2575 fprintf_filtered (stream
, current_substring
, 0);
2578 internal_error (__FILE__
, __LINE__
,
2579 _("failed internal consistency check"));
2581 /* Maybe advance to the next argument. */
2582 if (piece
.argclass
!= literal_piece
)
2588 /* Implement the "printf" command. */
2591 printf_command (const char *arg
, int from_tty
)
2593 ui_printf (arg
, gdb_stdout
);
2594 gdb_flush (gdb_stdout
);
2597 /* Implement the "eval" command. */
2600 eval_command (const char *arg
, int from_tty
)
2604 ui_printf (arg
, &stb
);
2606 std::string expanded
= insert_user_defined_cmd_args (stb
.c_str ());
2608 execute_command (expanded
.c_str (), from_tty
);
2612 _initialize_printcmd (void)
2614 struct cmd_list_element
*c
;
2616 current_display_number
= -1;
2618 gdb::observers::free_objfile
.attach (clear_dangling_display_expressions
);
2620 add_info ("address", info_address_command
,
2621 _("Describe where symbol SYM is stored."));
2623 add_info ("symbol", info_symbol_command
, _("\
2624 Describe what symbol is at location ADDR.\n\
2625 Only for symbols with fixed locations (global or static scope)."));
2627 add_com ("x", class_vars
, x_command
, _("\
2628 Examine memory: x/FMT ADDRESS.\n\
2629 ADDRESS is an expression for the memory address to examine.\n\
2630 FMT is a repeat count followed by a format letter and a size letter.\n\
2631 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2632 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2633 and z(hex, zero padded on the left).\n\
2634 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2635 The specified number of objects of the specified size are printed\n\
2636 according to the format. If a negative number is specified, memory is\n\
2637 examined backward from the address.\n\n\
2638 Defaults for format and size letters are those previously used.\n\
2639 Default count is 1. Default address is following last thing printed\n\
2640 with this command or \"print\"."));
2643 add_com ("whereis", class_vars
, whereis_command
,
2644 _("Print line number and file of definition of variable."));
2647 add_info ("display", info_display_command
, _("\
2648 Expressions to display when program stops, with code numbers."));
2650 add_cmd ("undisplay", class_vars
, undisplay_command
, _("\
2651 Cancel some expressions to be displayed when program stops.\n\
2652 Arguments are the code numbers of the expressions to stop displaying.\n\
2653 No argument means cancel all automatic-display expressions.\n\
2654 \"delete display\" has the same effect as this command.\n\
2655 Do \"info display\" to see current list of code numbers."),
2658 add_com ("display", class_vars
, display_command
, _("\
2659 Print value of expression EXP each time the program stops.\n\
2660 /FMT may be used before EXP as in the \"print\" command.\n\
2661 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2662 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2663 and examining is done as in the \"x\" command.\n\n\
2664 With no argument, display all currently requested auto-display expressions.\n\
2665 Use \"undisplay\" to cancel display requests previously made."));
2667 add_cmd ("display", class_vars
, enable_display_command
, _("\
2668 Enable some expressions to be displayed when program stops.\n\
2669 Arguments are the code numbers of the expressions to resume displaying.\n\
2670 No argument means enable all automatic-display expressions.\n\
2671 Do \"info display\" to see current list of code numbers."), &enablelist
);
2673 add_cmd ("display", class_vars
, disable_display_command
, _("\
2674 Disable some expressions to be displayed when program stops.\n\
2675 Arguments are the code numbers of the expressions to stop displaying.\n\
2676 No argument means disable all automatic-display expressions.\n\
2677 Do \"info display\" to see current list of code numbers."), &disablelist
);
2679 add_cmd ("display", class_vars
, undisplay_command
, _("\
2680 Cancel some expressions to be displayed when program stops.\n\
2681 Arguments are the code numbers of the expressions to stop displaying.\n\
2682 No argument means cancel all automatic-display expressions.\n\
2683 Do \"info display\" to see current list of code numbers."), &deletelist
);
2685 add_com ("printf", class_vars
, printf_command
, _("\
2686 Formatted printing, like the C \"printf\" function.\n\
2687 Usage: printf \"format string\", arg1, arg2, arg3, ..., argn\n\
2688 This supports most C printf format specifications, like %s, %d, etc."));
2690 add_com ("output", class_vars
, output_command
, _("\
2691 Like \"print\" but don't put in value history and don't print newline.\n\
2692 This is useful in user-defined commands."));
2694 add_prefix_cmd ("set", class_vars
, set_command
, _("\
2695 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2696 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2697 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2698 with $), a register (a few standard names starting with $), or an actual\n\
2699 variable in the program being debugged. EXP is any valid expression.\n\
2700 Use \"set variable\" for variables with names identical to set subcommands.\n\
2702 With a subcommand, this command modifies parts of the gdb environment.\n\
2703 You can see these environment settings with the \"show\" command."),
2704 &setlist
, "set ", 1, &cmdlist
);
2706 add_com ("assign", class_vars
, set_command
, _("\
2707 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2708 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2709 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2710 with $), a register (a few standard names starting with $), or an actual\n\
2711 variable in the program being debugged. EXP is any valid expression.\n\
2712 Use \"set variable\" for variables with names identical to set subcommands.\n\
2713 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2714 You can see these environment settings with the \"show\" command."));
2716 /* "call" is the same as "set", but handy for dbx users to call fns. */
2717 c
= add_com ("call", class_vars
, call_command
, _("\
2718 Call a function in the program.\n\
2719 The argument is the function name and arguments, in the notation of the\n\
2720 current working language. The result is printed and saved in the value\n\
2721 history, if it is not void."));
2722 set_cmd_completer (c
, expression_completer
);
2724 add_cmd ("variable", class_vars
, set_command
, _("\
2725 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2726 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2727 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2728 with $), a register (a few standard names starting with $), or an actual\n\
2729 variable in the program being debugged. EXP is any valid expression.\n\
2730 This may usually be abbreviated to simply \"set\"."),
2732 add_alias_cmd ("var", "variable", class_vars
, 0, &setlist
);
2734 c
= add_com ("print", class_vars
, print_command
, _("\
2735 Print value of expression EXP.\n\
2736 Variables accessible are those of the lexical environment of the selected\n\
2737 stack frame, plus all those whose scope is global or an entire file.\n\
2739 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2740 $$NUM refers to NUM'th value back from the last one.\n\
2741 Names starting with $ refer to registers (with the values they would have\n\
2742 if the program were to return to the stack frame now selected, restoring\n\
2743 all registers saved by frames farther in) or else to debugger\n\
2744 \"convenience\" variables (any such name not a known register).\n\
2745 Use assignment expressions to give values to convenience variables.\n\
2747 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2748 @ is a binary operator for treating consecutive data objects\n\
2749 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2750 element is FOO, whose second element is stored in the space following\n\
2751 where FOO is stored, etc. FOO must be an expression whose value\n\
2752 resides in memory.\n\
2754 EXP may be preceded with /FMT, where FMT is a format letter\n\
2755 but no count or size letter (see \"x\" command)."));
2756 set_cmd_completer (c
, expression_completer
);
2757 add_com_alias ("p", "print", class_vars
, 1);
2758 add_com_alias ("inspect", "print", class_vars
, 1);
2760 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class
,
2761 &max_symbolic_offset
, _("\
2762 Set the largest offset that will be printed in <symbol+1234> form."), _("\
2763 Show the largest offset that will be printed in <symbol+1234> form."), _("\
2764 Tell GDB to only display the symbolic form of an address if the\n\
2765 offset between the closest earlier symbol and the address is less than\n\
2766 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
2767 to always print the symbolic form of an address if any symbol precedes\n\
2768 it. Zero is equivalent to \"unlimited\"."),
2770 show_max_symbolic_offset
,
2771 &setprintlist
, &showprintlist
);
2772 add_setshow_boolean_cmd ("symbol-filename", no_class
,
2773 &print_symbol_filename
, _("\
2774 Set printing of source filename and line number with <symbol>."), _("\
2775 Show printing of source filename and line number with <symbol>."), NULL
,
2777 show_print_symbol_filename
,
2778 &setprintlist
, &showprintlist
);
2780 add_com ("eval", no_class
, eval_command
, _("\
2781 Convert \"printf format string\", arg1, arg2, arg3, ..., argn to\n\
2782 a command line, and call it."));