1 /* Print values for GNU debugger GDB.
3 Copyright (C) 1986-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
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"
49 #include "cli/cli-style.h"
50 #include "common/format.h"
52 #include "common/byte-vector.h"
54 /* Last specified output format. */
56 static char last_format
= 0;
58 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
60 static char last_size
= 'w';
62 /* Last specified count for the 'x' command. */
64 static int last_count
;
66 /* Default address to examine next, and associated architecture. */
68 static struct gdbarch
*next_gdbarch
;
69 static CORE_ADDR next_address
;
71 /* Number of delay instructions following current disassembled insn. */
73 static int branch_delay_insns
;
75 /* Last address examined. */
77 static CORE_ADDR last_examine_address
;
79 /* Contents of last address examined.
80 This is not valid past the end of the `x' command! */
82 static value_ref_ptr last_examine_value
;
84 /* Largest offset between a symbolic value and an address, that will be
85 printed as `0x1234 <symbol+offset>'. */
87 static unsigned int max_symbolic_offset
= UINT_MAX
;
89 show_max_symbolic_offset (struct ui_file
*file
, int from_tty
,
90 struct cmd_list_element
*c
, const char *value
)
92 fprintf_filtered (file
,
93 _("The largest offset that will be "
94 "printed in <symbol+1234> form is %s.\n"),
98 /* Append the source filename and linenumber of the symbol when
99 printing a symbolic value as `<symbol at filename:linenum>' if set. */
100 static int print_symbol_filename
= 0;
102 show_print_symbol_filename (struct ui_file
*file
, int from_tty
,
103 struct cmd_list_element
*c
, const char *value
)
105 fprintf_filtered (file
, _("Printing of source filename and "
106 "line number with <symbol> is %s.\n"),
110 /* Number of auto-display expression currently being displayed.
111 So that we can disable it if we get a signal within it.
112 -1 when not doing one. */
114 static int current_display_number
;
118 /* Chain link to next auto-display item. */
119 struct display
*next
;
121 /* The expression as the user typed it. */
124 /* Expression to be evaluated and displayed. */
127 /* Item number of this auto-display item. */
130 /* Display format specified. */
131 struct format_data format
;
133 /* Program space associated with `block'. */
134 struct program_space
*pspace
;
136 /* Innermost block required by this expression when evaluated. */
137 const struct block
*block
;
139 /* Status of this display (enabled or disabled). */
143 /* Chain of expressions whose values should be displayed
144 automatically each time the program stops. */
146 static struct display
*display_chain
;
148 static int display_number
;
150 /* Walk the following statement or block through all displays.
151 ALL_DISPLAYS_SAFE does so even if the statement deletes the current
154 #define ALL_DISPLAYS(B) \
155 for (B = display_chain; B; B = B->next)
157 #define ALL_DISPLAYS_SAFE(B,TMP) \
158 for (B = display_chain; \
159 B ? (TMP = B->next, 1): 0; \
162 /* Prototypes for local functions. */
164 static void do_one_display (struct display
*);
167 /* Decode a format specification. *STRING_PTR should point to it.
168 OFORMAT and OSIZE are used as defaults for the format and size
169 if none are given in the format specification.
170 If OSIZE is zero, then the size field of the returned value
171 should be set only if a size is explicitly specified by the
173 The structure returned describes all the data
174 found in the specification. In addition, *STRING_PTR is advanced
175 past the specification and past all whitespace following it. */
177 static struct format_data
178 decode_format (const char **string_ptr
, int oformat
, int osize
)
180 struct format_data val
;
181 const char *p
= *string_ptr
;
193 if (*p
>= '0' && *p
<= '9')
194 val
.count
*= atoi (p
);
195 while (*p
>= '0' && *p
<= '9')
198 /* Now process size or format letters that follow. */
202 if (*p
== 'b' || *p
== 'h' || *p
== 'w' || *p
== 'g')
209 else if (*p
>= 'a' && *p
<= 'z')
215 *string_ptr
= skip_spaces (p
);
217 /* Set defaults for format and size if not specified. */
218 if (val
.format
== '?')
222 /* Neither has been specified. */
223 val
.format
= oformat
;
227 /* If a size is specified, any format makes a reasonable
228 default except 'i'. */
229 val
.format
= oformat
== 'i' ? 'x' : oformat
;
231 else if (val
.size
== '?')
235 /* Pick the appropriate size for an address. This is deferred
236 until do_examine when we know the actual architecture to use.
237 A special size value of 'a' is used to indicate this case. */
238 val
.size
= osize
? 'a' : osize
;
241 /* Floating point has to be word or giantword. */
242 if (osize
== 'w' || osize
== 'g')
245 /* Default it to giantword if the last used size is not
247 val
.size
= osize
? 'g' : osize
;
250 /* Characters default to one byte. */
251 val
.size
= osize
? 'b' : osize
;
254 /* Display strings with byte size chars unless explicitly
260 /* The default is the size most recently specified. */
267 /* Print value VAL on stream according to OPTIONS.
268 Do not end with a newline.
269 SIZE is the letter for the size of datum being printed.
270 This is used to pad hex numbers so they line up. SIZE is 0
271 for print / output and set for examine. */
274 print_formatted (struct value
*val
, int size
,
275 const struct value_print_options
*options
,
276 struct ui_file
*stream
)
278 struct type
*type
= check_typedef (value_type (val
));
279 int len
= TYPE_LENGTH (type
);
281 if (VALUE_LVAL (val
) == lval_memory
)
282 next_address
= value_address (val
) + len
;
286 switch (options
->format
)
290 struct type
*elttype
= value_type (val
);
292 next_address
= (value_address (val
)
293 + val_print_string (elttype
, NULL
,
294 value_address (val
), -1,
295 stream
, options
) * len
);
300 /* We often wrap here if there are long symbolic names. */
302 next_address
= (value_address (val
)
303 + gdb_print_insn (get_type_arch (type
),
304 value_address (val
), stream
,
305 &branch_delay_insns
));
310 if (options
->format
== 0 || options
->format
== 's'
311 || TYPE_CODE (type
) == TYPE_CODE_REF
312 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
313 || TYPE_CODE (type
) == TYPE_CODE_STRING
314 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
315 || TYPE_CODE (type
) == TYPE_CODE_UNION
316 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
317 value_print (val
, stream
, options
);
319 /* User specified format, so don't look to the type to tell us
321 val_print_scalar_formatted (type
,
322 value_embedded_offset (val
),
324 options
, size
, stream
);
327 /* Return builtin floating point type of same length as TYPE.
328 If no such type is found, return TYPE itself. */
330 float_type_from_length (struct type
*type
)
332 struct gdbarch
*gdbarch
= get_type_arch (type
);
333 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
335 if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_float
))
336 type
= builtin
->builtin_float
;
337 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_double
))
338 type
= builtin
->builtin_double
;
339 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_long_double
))
340 type
= builtin
->builtin_long_double
;
345 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
346 according to OPTIONS and SIZE on STREAM. Formats s and i are not
347 supported at this level. */
350 print_scalar_formatted (const gdb_byte
*valaddr
, struct type
*type
,
351 const struct value_print_options
*options
,
352 int size
, struct ui_file
*stream
)
354 struct gdbarch
*gdbarch
= get_type_arch (type
);
355 unsigned int len
= TYPE_LENGTH (type
);
356 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
358 /* String printing should go through val_print_scalar_formatted. */
359 gdb_assert (options
->format
!= 's');
361 /* If the value is a pointer, and pointers and addresses are not the
362 same, then at this point, the value's length (in target bytes) is
363 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
364 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
365 len
= gdbarch_addr_bit (gdbarch
) / TARGET_CHAR_BIT
;
367 /* If we are printing it as unsigned, truncate it in case it is actually
368 a negative signed value (e.g. "print/u (short)-1" should print 65535
369 (if shorts are 16 bits) instead of 4294967295). */
370 if (options
->format
!= 'c'
371 && (options
->format
!= 'd' || TYPE_UNSIGNED (type
)))
373 if (len
< TYPE_LENGTH (type
) && byte_order
== BFD_ENDIAN_BIG
)
374 valaddr
+= TYPE_LENGTH (type
) - len
;
377 if (size
!= 0 && (options
->format
== 'x' || options
->format
== 't'))
379 /* Truncate to fit. */
396 error (_("Undefined output size \"%c\"."), size
);
398 if (newlen
< len
&& byte_order
== BFD_ENDIAN_BIG
)
399 valaddr
+= len
- newlen
;
403 /* Historically gdb has printed floats by first casting them to a
404 long, and then printing the long. PR cli/16242 suggests changing
405 this to using C-style hex float format. */
406 gdb::byte_vector converted_float_bytes
;
407 if (TYPE_CODE (type
) == TYPE_CODE_FLT
408 && (options
->format
== 'o'
409 || options
->format
== 'x'
410 || options
->format
== 't'
411 || options
->format
== 'z'
412 || options
->format
== 'd'
413 || options
->format
== 'u'))
415 LONGEST val_long
= unpack_long (type
, valaddr
);
416 converted_float_bytes
.resize (TYPE_LENGTH (type
));
417 store_signed_integer (converted_float_bytes
.data (), TYPE_LENGTH (type
),
418 byte_order
, val_long
);
419 valaddr
= converted_float_bytes
.data ();
422 /* Printing a non-float type as 'f' will interpret the data as if it were
423 of a floating-point type of the same length, if that exists. Otherwise,
424 the data is printed as integer. */
425 char format
= options
->format
;
426 if (format
== 'f' && TYPE_CODE (type
) != TYPE_CODE_FLT
)
428 type
= float_type_from_length (type
);
429 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
436 print_octal_chars (stream
, valaddr
, len
, byte_order
);
439 print_decimal_chars (stream
, valaddr
, len
, true, byte_order
);
442 print_decimal_chars (stream
, valaddr
, len
, false, byte_order
);
445 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
447 print_decimal_chars (stream
, valaddr
, len
, !TYPE_UNSIGNED (type
),
453 print_floating (valaddr
, type
, stream
);
457 print_binary_chars (stream
, valaddr
, len
, byte_order
, size
> 0);
460 print_hex_chars (stream
, valaddr
, len
, byte_order
, size
> 0);
463 print_hex_chars (stream
, valaddr
, len
, byte_order
, true);
467 struct value_print_options opts
= *options
;
469 LONGEST val_long
= unpack_long (type
, valaddr
);
472 if (TYPE_UNSIGNED (type
))
473 type
= builtin_type (gdbarch
)->builtin_true_unsigned_char
;
475 type
= builtin_type (gdbarch
)->builtin_true_char
;
477 value_print (value_from_longest (type
, val_long
), stream
, &opts
);
483 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
485 print_address (gdbarch
, addr
, stream
);
490 error (_("Undefined output format \"%c\"."), format
);
494 /* Specify default address for `x' command.
495 The `info lines' command uses this. */
498 set_next_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
500 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
502 next_gdbarch
= gdbarch
;
505 /* Make address available to the user as $_. */
506 set_internalvar (lookup_internalvar ("_"),
507 value_from_pointer (ptr_type
, addr
));
510 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
511 after LEADIN. Print nothing if no symbolic name is found nearby.
512 Optionally also print source file and line number, if available.
513 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
514 or to interpret it as a possible C++ name and convert it back to source
515 form. However note that DO_DEMANGLE can be overridden by the specific
516 settings of the demangle and asm_demangle variables. Returns
517 non-zero if anything was printed; zero otherwise. */
520 print_address_symbolic (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
521 struct ui_file
*stream
,
522 int do_demangle
, const char *leadin
)
524 std::string name
, filename
;
529 if (build_address_symbolic (gdbarch
, addr
, do_demangle
, &name
, &offset
,
530 &filename
, &line
, &unmapped
))
533 fputs_filtered (leadin
, stream
);
535 fputs_filtered ("<*", stream
);
537 fputs_filtered ("<", stream
);
538 fputs_styled (name
.c_str (), function_name_style
.style (), stream
);
540 fprintf_filtered (stream
, "+%u", (unsigned int) offset
);
542 /* Append source filename and line number if desired. Give specific
543 line # of this addr, if we have it; else line # of the nearest symbol. */
544 if (print_symbol_filename
&& !filename
.empty ())
546 fputs_filtered (line
== -1 ? " in " : " at ", stream
);
547 fputs_styled (filename
.c_str (), file_name_style
.style (), stream
);
549 fprintf_filtered (stream
, ":%d", line
);
552 fputs_filtered ("*>", stream
);
554 fputs_filtered (">", stream
);
559 /* See valprint.h. */
562 build_address_symbolic (struct gdbarch
*gdbarch
,
563 CORE_ADDR addr
, /* IN */
564 int do_demangle
, /* IN */
565 std::string
*name
, /* OUT */
566 int *offset
, /* OUT */
567 std::string
*filename
, /* OUT */
569 int *unmapped
) /* OUT */
571 struct bound_minimal_symbol msymbol
;
572 struct symbol
*symbol
;
573 CORE_ADDR name_location
= 0;
574 struct obj_section
*section
= NULL
;
575 const char *name_temp
= "";
577 /* Let's say it is mapped (not unmapped). */
580 /* Determine if the address is in an overlay, and whether it is
582 if (overlay_debugging
)
584 section
= find_pc_overlay (addr
);
585 if (pc_in_unmapped_range (addr
, section
))
588 addr
= overlay_mapped_address (addr
, section
);
592 /* First try to find the address in the symbol table, then
593 in the minsyms. Take the closest one. */
595 /* This is defective in the sense that it only finds text symbols. So
596 really this is kind of pointless--we should make sure that the
597 minimal symbols have everything we need (by changing that we could
598 save some memory, but for many debug format--ELF/DWARF or
599 anything/stabs--it would be inconvenient to eliminate those minimal
601 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
602 symbol
= find_pc_sect_function (addr
, section
);
606 /* If this is a function (i.e. a code address), strip out any
607 non-address bits. For instance, display a pointer to the
608 first instruction of a Thumb function as <function>; the
609 second instruction will be <function+2>, even though the
610 pointer is <function+3>. This matches the ISA behavior. */
611 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
613 name_location
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (symbol
));
614 if (do_demangle
|| asm_demangle
)
615 name_temp
= SYMBOL_PRINT_NAME (symbol
);
617 name_temp
= SYMBOL_LINKAGE_NAME (symbol
);
620 if (msymbol
.minsym
!= NULL
621 && MSYMBOL_HAS_SIZE (msymbol
.minsym
)
622 && MSYMBOL_SIZE (msymbol
.minsym
) == 0
623 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text
624 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text_gnu_ifunc
625 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_file_text
)
626 msymbol
.minsym
= NULL
;
628 if (msymbol
.minsym
!= NULL
)
630 if (BMSYMBOL_VALUE_ADDRESS (msymbol
) > name_location
|| symbol
== NULL
)
632 /* If this is a function (i.e. a code address), strip out any
633 non-address bits. For instance, display a pointer to the
634 first instruction of a Thumb function as <function>; the
635 second instruction will be <function+2>, even though the
636 pointer is <function+3>. This matches the ISA behavior. */
637 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_text
638 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_text_gnu_ifunc
639 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_text
640 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
641 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
643 /* The msymbol is closer to the address than the symbol;
644 use the msymbol instead. */
646 name_location
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
647 if (do_demangle
|| asm_demangle
)
648 name_temp
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
650 name_temp
= MSYMBOL_LINKAGE_NAME (msymbol
.minsym
);
653 if (symbol
== NULL
&& msymbol
.minsym
== NULL
)
656 /* If the nearest symbol is too far away, don't print anything symbolic. */
658 /* For when CORE_ADDR is larger than unsigned int, we do math in
659 CORE_ADDR. But when we detect unsigned wraparound in the
660 CORE_ADDR math, we ignore this test and print the offset,
661 because addr+max_symbolic_offset has wrapped through the end
662 of the address space back to the beginning, giving bogus comparison. */
663 if (addr
> name_location
+ max_symbolic_offset
664 && name_location
+ max_symbolic_offset
> name_location
)
667 *offset
= addr
- name_location
;
671 if (print_symbol_filename
)
673 struct symtab_and_line sal
;
675 sal
= find_pc_sect_line (addr
, section
, 0);
679 *filename
= symtab_to_filename_for_display (sal
.symtab
);
687 /* Print address ADDR symbolically on STREAM.
688 First print it as a number. Then perhaps print
689 <SYMBOL + OFFSET> after the number. */
692 print_address (struct gdbarch
*gdbarch
,
693 CORE_ADDR addr
, struct ui_file
*stream
)
695 fputs_styled (paddress (gdbarch
, addr
), address_style
.style (), stream
);
696 print_address_symbolic (gdbarch
, addr
, stream
, asm_demangle
, " ");
699 /* Return a prefix for instruction address:
700 "=> " for current instruction, else " ". */
703 pc_prefix (CORE_ADDR addr
)
705 if (has_stack_frames ())
707 struct frame_info
*frame
;
710 frame
= get_selected_frame (NULL
);
711 if (get_frame_pc_if_available (frame
, &pc
) && pc
== addr
)
717 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
718 controls whether to print the symbolic name "raw" or demangled.
719 Return non-zero if anything was printed; zero otherwise. */
722 print_address_demangle (const struct value_print_options
*opts
,
723 struct gdbarch
*gdbarch
, CORE_ADDR addr
,
724 struct ui_file
*stream
, int do_demangle
)
726 if (opts
->addressprint
)
728 fputs_styled (paddress (gdbarch
, addr
), address_style
.style (), stream
);
729 print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, " ");
733 return print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, "");
739 /* Find the address of the instruction that is INST_COUNT instructions before
740 the instruction at ADDR.
741 Since some architectures have variable-length instructions, we can't just
742 simply subtract INST_COUNT * INSN_LEN from ADDR. Instead, we use line
743 number information to locate the nearest known instruction boundary,
744 and disassemble forward from there. If we go out of the symbol range
745 during disassembling, we return the lowest address we've got so far and
746 set the number of instructions read to INST_READ. */
749 find_instruction_backward (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
750 int inst_count
, int *inst_read
)
752 /* The vector PCS is used to store instruction addresses within
754 CORE_ADDR loop_start
, loop_end
, p
;
755 std::vector
<CORE_ADDR
> pcs
;
756 struct symtab_and_line sal
;
759 loop_start
= loop_end
= addr
;
761 /* In each iteration of the outer loop, we get a pc range that ends before
762 LOOP_START, then we count and store every instruction address of the range
763 iterated in the loop.
764 If the number of instructions counted reaches INST_COUNT, return the
765 stored address that is located INST_COUNT instructions back from ADDR.
766 If INST_COUNT is not reached, we subtract the number of counted
767 instructions from INST_COUNT, and go to the next iteration. */
771 sal
= find_pc_sect_line (loop_start
, NULL
, 1);
774 /* We reach here when line info is not available. In this case,
775 we print a message and just exit the loop. The return value
776 is calculated after the loop. */
777 printf_filtered (_("No line number information available "
780 print_address (gdbarch
, loop_start
- 1, gdb_stdout
);
781 printf_filtered ("\n");
785 loop_end
= loop_start
;
788 /* This loop pushes instruction addresses in the range from
789 LOOP_START to LOOP_END. */
790 for (p
= loop_start
; p
< loop_end
;)
793 p
+= gdb_insn_length (gdbarch
, p
);
796 inst_count
-= pcs
.size ();
797 *inst_read
+= pcs
.size ();
799 while (inst_count
> 0);
801 /* After the loop, the vector PCS has instruction addresses of the last
802 source line we processed, and INST_COUNT has a negative value.
803 We return the address at the index of -INST_COUNT in the vector for
805 Let's assume the following instruction addresses and run 'x/-4i 0x400e'.
815 find_instruction_backward is called with INST_COUNT = 4 and expected to
816 return 0x4001. When we reach here, INST_COUNT is set to -1 because
817 it was subtracted by 2 (from Line Y) and 3 (from Line X). The value
818 4001 is located at the index 1 of the last iterated line (= Line X),
819 which is simply calculated by -INST_COUNT.
820 The case when the length of PCS is 0 means that we reached an area for
821 which line info is not available. In such case, we return LOOP_START,
822 which was the lowest instruction address that had line info. */
823 p
= pcs
.size () > 0 ? pcs
[-inst_count
] : loop_start
;
825 /* INST_READ includes all instruction addresses in a pc range. Need to
826 exclude the beginning part up to the address we're returning. That
827 is, exclude {0x4000} in the example above. */
829 *inst_read
+= inst_count
;
834 /* Backward read LEN bytes of target memory from address MEMADDR + LEN,
835 placing the results in GDB's memory from MYADDR + LEN. Returns
836 a count of the bytes actually read. */
839 read_memory_backward (struct gdbarch
*gdbarch
,
840 CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
843 int nread
; /* Number of bytes actually read. */
845 /* First try a complete read. */
846 errcode
= target_read_memory (memaddr
, myaddr
, len
);
854 /* Loop, reading one byte at a time until we get as much as we can. */
857 for (nread
= 0; nread
< len
; ++nread
)
859 errcode
= target_read_memory (--memaddr
, --myaddr
, 1);
862 /* The read was unsuccessful, so exit the loop. */
863 printf_filtered (_("Cannot access memory at address %s\n"),
864 paddress (gdbarch
, memaddr
));
872 /* Returns true if X (which is LEN bytes wide) is the number zero. */
875 integer_is_zero (const gdb_byte
*x
, int len
)
879 while (i
< len
&& x
[i
] == 0)
884 /* Find the start address of a string in which ADDR is included.
885 Basically we search for '\0' and return the next address,
886 but if OPTIONS->PRINT_MAX is smaller than the length of a string,
887 we stop searching and return the address to print characters as many as
888 PRINT_MAX from the string. */
891 find_string_backward (struct gdbarch
*gdbarch
,
892 CORE_ADDR addr
, int count
, int char_size
,
893 const struct value_print_options
*options
,
894 int *strings_counted
)
896 const int chunk_size
= 0x20;
899 int chars_to_read
= chunk_size
;
900 int chars_counted
= 0;
901 int count_original
= count
;
902 CORE_ADDR string_start_addr
= addr
;
904 gdb_assert (char_size
== 1 || char_size
== 2 || char_size
== 4);
905 gdb::byte_vector
buffer (chars_to_read
* char_size
);
906 while (count
> 0 && read_error
== 0)
910 addr
-= chars_to_read
* char_size
;
911 chars_read
= read_memory_backward (gdbarch
, addr
, buffer
.data (),
912 chars_to_read
* char_size
);
913 chars_read
/= char_size
;
914 read_error
= (chars_read
== chars_to_read
) ? 0 : 1;
915 /* Searching for '\0' from the end of buffer in backward direction. */
916 for (i
= 0; i
< chars_read
&& count
> 0 ; ++i
, ++chars_counted
)
918 int offset
= (chars_to_read
- i
- 1) * char_size
;
920 if (integer_is_zero (&buffer
[offset
], char_size
)
921 || chars_counted
== options
->print_max
)
923 /* Found '\0' or reached print_max. As OFFSET is the offset to
924 '\0', we add CHAR_SIZE to return the start address of
927 string_start_addr
= addr
+ offset
+ char_size
;
933 /* Update STRINGS_COUNTED with the actual number of loaded strings. */
934 *strings_counted
= count_original
- count
;
938 /* In error case, STRING_START_ADDR is pointing to the string that
939 was last successfully loaded. Rewind the partially loaded string. */
940 string_start_addr
-= chars_counted
* char_size
;
943 return string_start_addr
;
946 /* Examine data at address ADDR in format FMT.
947 Fetch it from memory and print on gdb_stdout. */
950 do_examine (struct format_data fmt
, struct gdbarch
*gdbarch
, CORE_ADDR addr
)
955 struct type
*val_type
= NULL
;
958 struct value_print_options opts
;
959 int need_to_update_next_address
= 0;
960 CORE_ADDR addr_rewound
= 0;
965 next_gdbarch
= gdbarch
;
968 /* Instruction format implies fetch single bytes
969 regardless of the specified size.
970 The case of strings is handled in decode_format, only explicit
971 size operator are not changed to 'b'. */
977 /* Pick the appropriate size for an address. */
978 if (gdbarch_ptr_bit (next_gdbarch
) == 64)
980 else if (gdbarch_ptr_bit (next_gdbarch
) == 32)
982 else if (gdbarch_ptr_bit (next_gdbarch
) == 16)
985 /* Bad value for gdbarch_ptr_bit. */
986 internal_error (__FILE__
, __LINE__
,
987 _("failed internal consistency check"));
991 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
992 else if (size
== 'h')
993 val_type
= builtin_type (next_gdbarch
)->builtin_int16
;
994 else if (size
== 'w')
995 val_type
= builtin_type (next_gdbarch
)->builtin_int32
;
996 else if (size
== 'g')
997 val_type
= builtin_type (next_gdbarch
)->builtin_int64
;
1001 struct type
*char_type
= NULL
;
1003 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
1004 if type is not found. */
1006 char_type
= builtin_type (next_gdbarch
)->builtin_char16
;
1007 else if (size
== 'w')
1008 char_type
= builtin_type (next_gdbarch
)->builtin_char32
;
1010 val_type
= char_type
;
1013 if (size
!= '\0' && size
!= 'b')
1014 warning (_("Unable to display strings with "
1015 "size '%c', using 'b' instead."), size
);
1017 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1026 if (format
== 's' || format
== 'i')
1029 get_formatted_print_options (&opts
, format
);
1033 /* This is the negative repeat count case.
1034 We rewind the address based on the given repeat count and format,
1035 then examine memory from there in forward direction. */
1040 next_address
= find_instruction_backward (gdbarch
, addr
, count
,
1043 else if (format
== 's')
1045 next_address
= find_string_backward (gdbarch
, addr
, count
,
1046 TYPE_LENGTH (val_type
),
1051 next_address
= addr
- count
* TYPE_LENGTH (val_type
);
1054 /* The following call to print_formatted updates next_address in every
1055 iteration. In backward case, we store the start address here
1056 and update next_address with it before exiting the function. */
1057 addr_rewound
= (format
== 's'
1058 ? next_address
- TYPE_LENGTH (val_type
)
1060 need_to_update_next_address
= 1;
1063 /* Print as many objects as specified in COUNT, at most maxelts per line,
1064 with the address of the next one at the start of each line. */
1070 fputs_filtered (pc_prefix (next_address
), gdb_stdout
);
1071 print_address (next_gdbarch
, next_address
, gdb_stdout
);
1072 printf_filtered (":");
1077 printf_filtered ("\t");
1078 /* Note that print_formatted sets next_address for the next
1080 last_examine_address
= next_address
;
1082 /* The value to be displayed is not fetched greedily.
1083 Instead, to avoid the possibility of a fetched value not
1084 being used, its retrieval is delayed until the print code
1085 uses it. When examining an instruction stream, the
1086 disassembler will perform its own memory fetch using just
1087 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
1088 the disassembler be modified so that LAST_EXAMINE_VALUE
1089 is left with the byte sequence from the last complete
1090 instruction fetched from memory? */
1092 = release_value (value_at_lazy (val_type
, next_address
));
1094 print_formatted (last_examine_value
.get (), size
, &opts
, gdb_stdout
);
1096 /* Display any branch delay slots following the final insn. */
1097 if (format
== 'i' && count
== 1)
1098 count
+= branch_delay_insns
;
1100 printf_filtered ("\n");
1103 if (need_to_update_next_address
)
1104 next_address
= addr_rewound
;
1108 validate_format (struct format_data fmt
, const char *cmdname
)
1111 error (_("Size letters are meaningless in \"%s\" command."), cmdname
);
1113 error (_("Item count other than 1 is meaningless in \"%s\" command."),
1115 if (fmt
.format
== 'i')
1116 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
1117 fmt
.format
, cmdname
);
1120 /* Parse print command format string into *FMTP and update *EXPP.
1121 CMDNAME should name the current command. */
1124 print_command_parse_format (const char **expp
, const char *cmdname
,
1125 struct format_data
*fmtp
)
1127 const char *exp
= *expp
;
1129 if (exp
&& *exp
== '/')
1132 *fmtp
= decode_format (&exp
, last_format
, 0);
1133 validate_format (*fmtp
, cmdname
);
1134 last_format
= fmtp
->format
;
1147 /* Print VAL to console according to *FMTP, including recording it to
1151 print_value (struct value
*val
, const struct format_data
*fmtp
)
1153 struct value_print_options opts
;
1154 int histindex
= record_latest_value (val
);
1156 annotate_value_history_begin (histindex
, value_type (val
));
1158 printf_filtered ("$%d = ", histindex
);
1160 annotate_value_history_value ();
1162 get_formatted_print_options (&opts
, fmtp
->format
);
1163 opts
.raw
= fmtp
->raw
;
1165 print_formatted (val
, fmtp
->size
, &opts
, gdb_stdout
);
1166 printf_filtered ("\n");
1168 annotate_value_history_end ();
1171 /* Evaluate string EXP as an expression in the current language and
1172 print the resulting value. EXP may contain a format specifier as the
1173 first argument ("/x myvar" for example, to print myvar in hex). */
1176 print_command_1 (const char *exp
, int voidprint
)
1179 struct format_data fmt
;
1181 print_command_parse_format (&exp
, "print", &fmt
);
1185 expression_up expr
= parse_expression (exp
);
1186 val
= evaluate_expression (expr
.get ());
1189 val
= access_value_history (0);
1191 if (voidprint
|| (val
&& value_type (val
) &&
1192 TYPE_CODE (value_type (val
)) != TYPE_CODE_VOID
))
1193 print_value (val
, &fmt
);
1197 print_command (const char *exp
, int from_tty
)
1199 print_command_1 (exp
, 1);
1202 /* Same as print, except it doesn't print void results. */
1204 call_command (const char *exp
, int from_tty
)
1206 print_command_1 (exp
, 0);
1209 /* Implementation of the "output" command. */
1212 output_command (const char *exp
, int from_tty
)
1216 struct format_data fmt
;
1217 struct value_print_options opts
;
1222 if (exp
&& *exp
== '/')
1225 fmt
= decode_format (&exp
, 0, 0);
1226 validate_format (fmt
, "output");
1227 format
= fmt
.format
;
1230 expression_up expr
= parse_expression (exp
);
1232 val
= evaluate_expression (expr
.get ());
1234 annotate_value_begin (value_type (val
));
1236 get_formatted_print_options (&opts
, format
);
1238 print_formatted (val
, fmt
.size
, &opts
, gdb_stdout
);
1240 annotate_value_end ();
1243 gdb_flush (gdb_stdout
);
1247 set_command (const char *exp
, int from_tty
)
1249 expression_up expr
= parse_expression (exp
);
1251 if (expr
->nelts
>= 1)
1252 switch (expr
->elts
[0].opcode
)
1254 case UNOP_PREINCREMENT
:
1255 case UNOP_POSTINCREMENT
:
1256 case UNOP_PREDECREMENT
:
1257 case UNOP_POSTDECREMENT
:
1259 case BINOP_ASSIGN_MODIFY
:
1264 (_("Expression is not an assignment (and might have no effect)"));
1267 evaluate_expression (expr
.get ());
1271 info_symbol_command (const char *arg
, int from_tty
)
1273 struct minimal_symbol
*msymbol
;
1274 struct obj_section
*osect
;
1275 CORE_ADDR addr
, sect_addr
;
1277 unsigned int offset
;
1280 error_no_arg (_("address"));
1282 addr
= parse_and_eval_address (arg
);
1283 for (objfile
*objfile
: current_program_space
->objfiles ())
1284 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
1286 /* Only process each object file once, even if there's a separate
1288 if (objfile
->separate_debug_objfile_backlink
)
1291 sect_addr
= overlay_mapped_address (addr
, osect
);
1293 if (obj_section_addr (osect
) <= sect_addr
1294 && sect_addr
< obj_section_endaddr (osect
)
1296 = lookup_minimal_symbol_by_pc_section (sect_addr
,
1299 const char *obj_name
, *mapped
, *sec_name
, *msym_name
;
1300 const char *loc_string
;
1303 offset
= sect_addr
- MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
);
1304 mapped
= section_is_mapped (osect
) ? _("mapped") : _("unmapped");
1305 sec_name
= osect
->the_bfd_section
->name
;
1306 msym_name
= MSYMBOL_PRINT_NAME (msymbol
);
1308 /* Don't print the offset if it is zero.
1309 We assume there's no need to handle i18n of "sym + offset". */
1310 std::string string_holder
;
1313 string_holder
= string_printf ("%s + %u", msym_name
, offset
);
1314 loc_string
= string_holder
.c_str ();
1317 loc_string
= msym_name
;
1319 gdb_assert (osect
->objfile
&& objfile_name (osect
->objfile
));
1320 obj_name
= objfile_name (osect
->objfile
);
1322 if (MULTI_OBJFILE_P ())
1323 if (pc_in_unmapped_range (addr
, osect
))
1324 if (section_is_overlay (osect
))
1325 printf_filtered (_("%s in load address range of "
1326 "%s overlay section %s of %s\n"),
1327 loc_string
, mapped
, sec_name
, obj_name
);
1329 printf_filtered (_("%s in load address range of "
1330 "section %s of %s\n"),
1331 loc_string
, sec_name
, obj_name
);
1333 if (section_is_overlay (osect
))
1334 printf_filtered (_("%s in %s overlay section %s of %s\n"),
1335 loc_string
, mapped
, sec_name
, obj_name
);
1337 printf_filtered (_("%s in section %s of %s\n"),
1338 loc_string
, sec_name
, obj_name
);
1340 if (pc_in_unmapped_range (addr
, osect
))
1341 if (section_is_overlay (osect
))
1342 printf_filtered (_("%s in load address range of %s overlay "
1344 loc_string
, mapped
, sec_name
);
1347 (_("%s in load address range of section %s\n"),
1348 loc_string
, sec_name
);
1350 if (section_is_overlay (osect
))
1351 printf_filtered (_("%s in %s overlay section %s\n"),
1352 loc_string
, mapped
, sec_name
);
1354 printf_filtered (_("%s in section %s\n"),
1355 loc_string
, sec_name
);
1359 printf_filtered (_("No symbol matches %s.\n"), arg
);
1363 info_address_command (const char *exp
, int from_tty
)
1365 struct gdbarch
*gdbarch
;
1368 struct bound_minimal_symbol msymbol
;
1370 struct obj_section
*section
;
1371 CORE_ADDR load_addr
, context_pc
= 0;
1372 struct field_of_this_result is_a_field_of_this
;
1375 error (_("Argument required."));
1377 sym
= lookup_symbol (exp
, get_selected_block (&context_pc
), VAR_DOMAIN
,
1378 &is_a_field_of_this
).symbol
;
1381 if (is_a_field_of_this
.type
!= NULL
)
1383 printf_filtered ("Symbol \"");
1384 fprintf_symbol_filtered (gdb_stdout
, exp
,
1385 current_language
->la_language
, DMGL_ANSI
);
1386 printf_filtered ("\" is a field of the local class variable ");
1387 if (current_language
->la_language
== language_objc
)
1388 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1390 printf_filtered ("`this'\n");
1394 msymbol
= lookup_bound_minimal_symbol (exp
);
1396 if (msymbol
.minsym
!= NULL
)
1398 struct objfile
*objfile
= msymbol
.objfile
;
1400 gdbarch
= get_objfile_arch (objfile
);
1401 load_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
1403 printf_filtered ("Symbol \"");
1404 fprintf_symbol_filtered (gdb_stdout
, exp
,
1405 current_language
->la_language
, DMGL_ANSI
);
1406 printf_filtered ("\" is at ");
1407 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1409 printf_filtered (" in a file compiled without debugging");
1410 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
1411 if (section_is_overlay (section
))
1413 load_addr
= overlay_unmapped_address (load_addr
, section
);
1414 printf_filtered (",\n -- loaded at ");
1415 fputs_styled (paddress (gdbarch
, load_addr
),
1416 address_style
.style (),
1418 printf_filtered (" in overlay section %s",
1419 section
->the_bfd_section
->name
);
1421 printf_filtered (".\n");
1424 error (_("No symbol \"%s\" in current context."), exp
);
1428 printf_filtered ("Symbol \"");
1429 fprintf_symbol_filtered (gdb_stdout
, SYMBOL_PRINT_NAME (sym
),
1430 current_language
->la_language
, DMGL_ANSI
);
1431 printf_filtered ("\" is ");
1432 val
= SYMBOL_VALUE (sym
);
1433 if (SYMBOL_OBJFILE_OWNED (sym
))
1434 section
= SYMBOL_OBJ_SECTION (symbol_objfile (sym
), sym
);
1437 gdbarch
= symbol_arch (sym
);
1439 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
1441 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, context_pc
,
1443 printf_filtered (".\n");
1447 switch (SYMBOL_CLASS (sym
))
1450 case LOC_CONST_BYTES
:
1451 printf_filtered ("constant");
1455 printf_filtered ("a label at address ");
1456 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1457 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1459 if (section_is_overlay (section
))
1461 load_addr
= overlay_unmapped_address (load_addr
, section
);
1462 printf_filtered (",\n -- loaded at ");
1463 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1465 printf_filtered (" in overlay section %s",
1466 section
->the_bfd_section
->name
);
1471 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
1474 /* GDBARCH is the architecture associated with the objfile the symbol
1475 is defined in; the target architecture may be different, and may
1476 provide additional registers. However, we do not know the target
1477 architecture at this point. We assume the objfile architecture
1478 will contain all the standard registers that occur in debug info
1480 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1482 if (SYMBOL_IS_ARGUMENT (sym
))
1483 printf_filtered (_("an argument in register %s"),
1484 gdbarch_register_name (gdbarch
, regno
));
1486 printf_filtered (_("a variable in register %s"),
1487 gdbarch_register_name (gdbarch
, regno
));
1491 printf_filtered (_("static storage at address "));
1492 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1493 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1495 if (section_is_overlay (section
))
1497 load_addr
= overlay_unmapped_address (load_addr
, section
);
1498 printf_filtered (_(",\n -- loaded at "));
1499 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1501 printf_filtered (_(" in overlay section %s"),
1502 section
->the_bfd_section
->name
);
1506 case LOC_REGPARM_ADDR
:
1507 /* Note comment at LOC_REGISTER. */
1508 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1509 printf_filtered (_("address of an argument in register %s"),
1510 gdbarch_register_name (gdbarch
, regno
));
1514 printf_filtered (_("an argument at offset %ld"), val
);
1518 printf_filtered (_("a local variable at frame offset %ld"), val
);
1522 printf_filtered (_("a reference argument at offset %ld"), val
);
1526 printf_filtered (_("a typedef"));
1530 printf_filtered (_("a function at address "));
1531 load_addr
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
));
1532 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1534 if (section_is_overlay (section
))
1536 load_addr
= overlay_unmapped_address (load_addr
, section
);
1537 printf_filtered (_(",\n -- loaded at "));
1538 fputs_styled (paddress (gdbarch
, load_addr
), address_style
.style (),
1540 printf_filtered (_(" in overlay section %s"),
1541 section
->the_bfd_section
->name
);
1545 case LOC_UNRESOLVED
:
1547 struct bound_minimal_symbol msym
;
1549 msym
= lookup_bound_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
));
1550 if (msym
.minsym
== NULL
)
1551 printf_filtered ("unresolved");
1554 section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
1557 && (section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
1559 load_addr
= MSYMBOL_VALUE_RAW_ADDRESS (msym
.minsym
);
1560 printf_filtered (_("a thread-local variable at offset %s "
1561 "in the thread-local storage for `%s'"),
1562 paddress (gdbarch
, load_addr
),
1563 objfile_name (section
->objfile
));
1567 load_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
1568 printf_filtered (_("static storage at address "));
1569 fputs_styled (paddress (gdbarch
, load_addr
),
1570 address_style
.style (), gdb_stdout
);
1571 if (section_is_overlay (section
))
1573 load_addr
= overlay_unmapped_address (load_addr
, section
);
1574 printf_filtered (_(",\n -- loaded at "));
1575 fputs_styled (paddress (gdbarch
, load_addr
),
1576 address_style
.style (),
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_tracker tracker
;
1719 expression_up expr
= parse_expression (exp
, &tracker
);
1721 newobj
= new display ();
1723 newobj
->exp_string
= xstrdup (exp
);
1724 newobj
->exp
= std::move (expr
);
1725 newobj
->block
= tracker
.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_tracker tracker
;
1887 d
->exp
= parse_expression (d
->exp_string
, &tracker
);
1888 d
->block
= tracker
.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
.what ());
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"),
1965 struct value_print_options opts
;
1967 annotate_display_format ();
1969 if (d
->format
.format
)
1970 printf_filtered ("/%c ", d
->format
.format
);
1972 annotate_display_expression ();
1974 puts_filtered (d
->exp_string
);
1975 annotate_display_expression_end ();
1977 printf_filtered (" = ");
1979 annotate_display_expression ();
1981 get_formatted_print_options (&opts
, d
->format
.format
);
1982 opts
.raw
= d
->format
.raw
;
1988 val
= evaluate_expression (d
->exp
.get ());
1989 print_formatted (val
, d
->format
.size
, &opts
, gdb_stdout
);
1991 CATCH (ex
, RETURN_MASK_ERROR
)
1993 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.what ());
1997 printf_filtered ("\n");
2000 annotate_display_end ();
2002 gdb_flush (gdb_stdout
);
2005 /* Display all of the values on the auto-display chain which can be
2006 evaluated in the current scope. */
2013 for (d
= display_chain
; d
; d
= d
->next
)
2017 /* Delete the auto-display which we were in the process of displaying.
2018 This is done when there is an error or a signal. */
2021 disable_display (int num
)
2025 for (d
= display_chain
; d
; d
= d
->next
)
2026 if (d
->number
== num
)
2031 printf_unfiltered (_("No display number %d.\n"), num
);
2035 disable_current_display (void)
2037 if (current_display_number
>= 0)
2039 disable_display (current_display_number
);
2040 fprintf_unfiltered (gdb_stderr
,
2041 _("Disabling display %d to "
2042 "avoid infinite recursion.\n"),
2043 current_display_number
);
2045 current_display_number
= -1;
2049 info_display_command (const char *ignore
, int from_tty
)
2054 printf_unfiltered (_("There are no auto-display expressions now.\n"));
2056 printf_filtered (_("Auto-display expressions now in effect:\n\
2057 Num Enb Expression\n"));
2059 for (d
= display_chain
; d
; d
= d
->next
)
2061 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
2063 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
2065 else if (d
->format
.format
)
2066 printf_filtered ("/%c ", d
->format
.format
);
2067 puts_filtered (d
->exp_string
);
2068 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
))
2069 printf_filtered (_(" (cannot be evaluated in the current context)"));
2070 printf_filtered ("\n");
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 fputs_filtered (n_spaces (2 * indent
), stream
);
2174 fputs_styled (name
, variable_name_style
.style (), stream
);
2175 fputs_filtered (" = ", stream
);
2180 struct value_print_options opts
;
2182 /* READ_VAR_VALUE needs a block in order to deal with non-local
2183 references (i.e. to handle nested functions). In this context, we
2184 print variables that are local to this frame, so we can avoid passing
2186 val
= read_var_value (var
, NULL
, frame
);
2187 get_user_print_options (&opts
);
2189 common_val_print (val
, stream
, indent
, &opts
, current_language
);
2191 /* common_val_print invalidates FRAME when a pretty printer calls inferior
2195 CATCH (except
, RETURN_MASK_ERROR
)
2197 fprintf_filtered (stream
, "<error reading variable %s (%s)>", name
,
2202 fprintf_filtered (stream
, "\n");
2205 /* Subroutine of ui_printf to simplify it.
2206 Print VALUE to STREAM using FORMAT.
2207 VALUE is a C-style string on the target. */
2210 printf_c_string (struct ui_file
*stream
, const char *format
,
2211 struct value
*value
)
2217 tem
= value_as_address (value
);
2221 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2222 fprintf_filtered (stream
, format
, "(null)");
2227 /* This is a %s argument. Find the length of the string. */
2233 read_memory (tem
+ j
, &c
, 1);
2238 /* Copy the string contents into a string inside GDB. */
2239 str
= (gdb_byte
*) alloca (j
+ 1);
2241 read_memory (tem
, str
, j
);
2245 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2246 fprintf_filtered (stream
, format
, (char *) str
);
2250 /* Subroutine of ui_printf to simplify it.
2251 Print VALUE to STREAM using FORMAT.
2252 VALUE is a wide C-style string on the target. */
2255 printf_wide_c_string (struct ui_file
*stream
, const char *format
,
2256 struct value
*value
)
2261 struct gdbarch
*gdbarch
= get_type_arch (value_type (value
));
2262 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2263 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2264 "wchar_t", NULL
, 0);
2265 int wcwidth
= TYPE_LENGTH (wctype
);
2266 gdb_byte
*buf
= (gdb_byte
*) alloca (wcwidth
);
2268 tem
= value_as_address (value
);
2272 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2273 fprintf_filtered (stream
, format
, "(null)");
2278 /* This is a %s argument. Find the length of the string. */
2279 for (j
= 0;; j
+= wcwidth
)
2282 read_memory (tem
+ j
, buf
, wcwidth
);
2283 if (extract_unsigned_integer (buf
, wcwidth
, byte_order
) == 0)
2287 /* Copy the string contents into a string inside GDB. */
2288 str
= (gdb_byte
*) alloca (j
+ wcwidth
);
2290 read_memory (tem
, str
, j
);
2291 memset (&str
[j
], 0, wcwidth
);
2293 auto_obstack output
;
2295 convert_between_encodings (target_wide_charset (gdbarch
),
2298 &output
, translit_char
);
2299 obstack_grow_str0 (&output
, "");
2302 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2303 fprintf_filtered (stream
, format
, obstack_base (&output
));
2307 /* Subroutine of ui_printf to simplify it.
2308 Print VALUE, a floating point value, to STREAM using FORMAT. */
2311 printf_floating (struct ui_file
*stream
, const char *format
,
2312 struct value
*value
, enum argclass argclass
)
2314 /* Parameter data. */
2315 struct type
*param_type
= value_type (value
);
2316 struct gdbarch
*gdbarch
= get_type_arch (param_type
);
2318 /* Determine target type corresponding to the format string. */
2319 struct type
*fmt_type
;
2323 fmt_type
= builtin_type (gdbarch
)->builtin_double
;
2325 case long_double_arg
:
2326 fmt_type
= builtin_type (gdbarch
)->builtin_long_double
;
2328 case dec32float_arg
:
2329 fmt_type
= builtin_type (gdbarch
)->builtin_decfloat
;
2331 case dec64float_arg
:
2332 fmt_type
= builtin_type (gdbarch
)->builtin_decdouble
;
2334 case dec128float_arg
:
2335 fmt_type
= builtin_type (gdbarch
)->builtin_declong
;
2338 gdb_assert_not_reached ("unexpected argument class");
2341 /* To match the traditional GDB behavior, the conversion is
2342 done differently depending on the type of the parameter:
2344 - if the parameter has floating-point type, it's value
2345 is converted to the target type;
2347 - otherwise, if the parameter has a type that is of the
2348 same size as a built-in floating-point type, the value
2349 bytes are interpreted as if they were of that type, and
2350 then converted to the target type (this is not done for
2351 decimal floating-point argument classes);
2353 - otherwise, if the source value has an integer value,
2354 it's value is converted to the target type;
2356 - otherwise, an error is raised.
2358 In either case, the result of the conversion is a byte buffer
2359 formatted in the target format for the target type. */
2361 if (TYPE_CODE (fmt_type
) == TYPE_CODE_FLT
)
2363 param_type
= float_type_from_length (param_type
);
2364 if (param_type
!= value_type (value
))
2365 value
= value_from_contents (param_type
, value_contents (value
));
2368 value
= value_cast (fmt_type
, value
);
2370 /* Convert the value to a string and print it. */
2372 = target_float_to_string (value_contents (value
), fmt_type
, format
);
2373 fputs_filtered (str
.c_str (), stream
);
2376 /* Subroutine of ui_printf to simplify it.
2377 Print VALUE, a target pointer, to STREAM using FORMAT. */
2380 printf_pointer (struct ui_file
*stream
, const char *format
,
2381 struct value
*value
)
2383 /* We avoid the host's %p because pointers are too
2384 likely to be the wrong size. The only interesting
2385 modifier for %p is a width; extract that, and then
2386 handle %p as glibc would: %#x or a literal "(nil)". */
2390 #ifdef PRINTF_HAS_LONG_LONG
2391 long long val
= value_as_long (value
);
2393 long val
= value_as_long (value
);
2396 fmt
= (char *) alloca (strlen (format
) + 5);
2398 /* Copy up to the leading %. */
2403 int is_percent
= (*p
== '%');
2418 /* Copy any width or flags. Only the "-" flag is valid for pointers
2419 -- see the format_pieces constructor. */
2420 while (*p
== '-' || (*p
>= '0' && *p
< '9'))
2423 gdb_assert (*p
== 'p' && *(p
+ 1) == '\0');
2426 #ifdef PRINTF_HAS_LONG_LONG
2433 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2434 fprintf_filtered (stream
, fmt
, val
);
2442 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2443 fprintf_filtered (stream
, fmt
, "(nil)");
2448 /* printf "printf format string" ARG to STREAM. */
2451 ui_printf (const char *arg
, struct ui_file
*stream
)
2453 const char *s
= arg
;
2454 std::vector
<struct value
*> val_args
;
2457 error_no_arg (_("format-control string and values to print"));
2459 s
= skip_spaces (s
);
2461 /* A format string should follow, enveloped in double quotes. */
2463 error (_("Bad format string, missing '\"'."));
2465 format_pieces
fpieces (&s
);
2468 error (_("Bad format string, non-terminated '\"'."));
2470 s
= skip_spaces (s
);
2472 if (*s
!= ',' && *s
!= 0)
2473 error (_("Invalid argument syntax"));
2477 s
= skip_spaces (s
);
2482 const char *current_substring
;
2485 for (auto &&piece
: fpieces
)
2486 if (piece
.argclass
!= literal_piece
)
2489 /* Now, parse all arguments and evaluate them.
2490 Store the VALUEs in VAL_ARGS. */
2497 val_args
.push_back (parse_to_comma_and_eval (&s1
));
2504 if (val_args
.size () != nargs_wanted
)
2505 error (_("Wrong number of arguments for specified format-string"));
2507 /* Now actually print them. */
2509 for (auto &&piece
: fpieces
)
2511 current_substring
= piece
.string
;
2512 switch (piece
.argclass
)
2515 printf_c_string (stream
, current_substring
, val_args
[i
]);
2517 case wide_string_arg
:
2518 printf_wide_c_string (stream
, current_substring
, val_args
[i
]);
2522 struct gdbarch
*gdbarch
2523 = get_type_arch (value_type (val_args
[i
]));
2524 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2525 "wchar_t", NULL
, 0);
2526 struct type
*valtype
;
2527 const gdb_byte
*bytes
;
2529 valtype
= value_type (val_args
[i
]);
2530 if (TYPE_LENGTH (valtype
) != TYPE_LENGTH (wctype
)
2531 || TYPE_CODE (valtype
) != TYPE_CODE_INT
)
2532 error (_("expected wchar_t argument for %%lc"));
2534 bytes
= value_contents (val_args
[i
]);
2536 auto_obstack output
;
2538 convert_between_encodings (target_wide_charset (gdbarch
),
2540 bytes
, TYPE_LENGTH (valtype
),
2541 TYPE_LENGTH (valtype
),
2542 &output
, translit_char
);
2543 obstack_grow_str0 (&output
, "");
2546 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2547 fprintf_filtered (stream
, current_substring
,
2548 obstack_base (&output
));
2553 #ifdef PRINTF_HAS_LONG_LONG
2555 long long val
= value_as_long (val_args
[i
]);
2558 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2559 fprintf_filtered (stream
, current_substring
, val
);
2564 error (_("long long not supported in printf"));
2568 int val
= value_as_long (val_args
[i
]);
2571 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2572 fprintf_filtered (stream
, current_substring
, val
);
2578 long val
= value_as_long (val_args
[i
]);
2581 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2582 fprintf_filtered (stream
, current_substring
, val
);
2586 /* Handles floating-point values. */
2588 case long_double_arg
:
2589 case dec32float_arg
:
2590 case dec64float_arg
:
2591 case dec128float_arg
:
2592 printf_floating (stream
, current_substring
, val_args
[i
],
2596 printf_pointer (stream
, current_substring
, val_args
[i
]);
2599 /* Print a portion of the format string that has no
2600 directives. Note that this will not include any
2601 ordinary %-specs, but it might include "%%". That is
2602 why we use printf_filtered and not puts_filtered here.
2603 Also, we pass a dummy argument because some platforms
2604 have modified GCC to include -Wformat-security by
2605 default, which will warn here if there is no
2608 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2609 fprintf_filtered (stream
, current_substring
, 0);
2613 internal_error (__FILE__
, __LINE__
,
2614 _("failed internal consistency check"));
2616 /* Maybe advance to the next argument. */
2617 if (piece
.argclass
!= literal_piece
)
2623 /* Implement the "printf" command. */
2626 printf_command (const char *arg
, int from_tty
)
2628 ui_printf (arg
, gdb_stdout
);
2629 reset_terminal_style (gdb_stdout
);
2631 gdb_flush (gdb_stdout
);
2634 /* Implement the "eval" command. */
2637 eval_command (const char *arg
, int from_tty
)
2641 ui_printf (arg
, &stb
);
2643 std::string expanded
= insert_user_defined_cmd_args (stb
.c_str ());
2645 execute_command (expanded
.c_str (), from_tty
);
2649 _initialize_printcmd (void)
2651 struct cmd_list_element
*c
;
2653 current_display_number
= -1;
2655 gdb::observers::free_objfile
.attach (clear_dangling_display_expressions
);
2657 add_info ("address", info_address_command
,
2658 _("Describe where symbol SYM is stored.\n\
2659 Usage: info address SYM"));
2661 add_info ("symbol", info_symbol_command
, _("\
2662 Describe what symbol is at location ADDR.\n\
2663 Usage: info symbol ADDR\n\
2664 Only for symbols with fixed locations (global or static scope)."));
2666 add_com ("x", class_vars
, x_command
, _("\
2667 Examine memory: x/FMT ADDRESS.\n\
2668 ADDRESS is an expression for the memory address to examine.\n\
2669 FMT is a repeat count followed by a format letter and a size letter.\n\
2670 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2671 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2672 and z(hex, zero padded on the left).\n\
2673 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2674 The specified number of objects of the specified size are printed\n\
2675 according to the format. If a negative number is specified, memory is\n\
2676 examined backward from the address.\n\n\
2677 Defaults for format and size letters are those previously used.\n\
2678 Default count is 1. Default address is following last thing printed\n\
2679 with this command or \"print\"."));
2681 add_info ("display", info_display_command
, _("\
2682 Expressions to display when program stops, with code numbers.\n\
2683 Usage: info display"));
2685 add_cmd ("undisplay", class_vars
, undisplay_command
, _("\
2686 Cancel some expressions to be displayed when program stops.\n\
2687 Usage: undisplay [NUM]...\n\
2688 Arguments are the code numbers of the expressions to stop displaying.\n\
2689 No argument means cancel all automatic-display expressions.\n\
2690 \"delete display\" has the same effect as this command.\n\
2691 Do \"info display\" to see current list of code numbers."),
2694 add_com ("display", class_vars
, display_command
, _("\
2695 Print value of expression EXP each time the program stops.\n\
2696 Usage: display[/FMT] EXP\n\
2697 /FMT may be used before EXP as in the \"print\" command.\n\
2698 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2699 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2700 and examining is done as in the \"x\" command.\n\n\
2701 With no argument, display all currently requested auto-display expressions.\n\
2702 Use \"undisplay\" to cancel display requests previously made."));
2704 add_cmd ("display", class_vars
, enable_display_command
, _("\
2705 Enable some expressions to be displayed when program stops.\n\
2706 Usage: enable display [NUM]...\n\
2707 Arguments are the code numbers of the expressions to resume displaying.\n\
2708 No argument means enable all automatic-display expressions.\n\
2709 Do \"info display\" to see current list of code numbers."), &enablelist
);
2711 add_cmd ("display", class_vars
, disable_display_command
, _("\
2712 Disable some expressions to be displayed when program stops.\n\
2713 Usage: disable display [NUM]...\n\
2714 Arguments are the code numbers of the expressions to stop displaying.\n\
2715 No argument means disable all automatic-display expressions.\n\
2716 Do \"info display\" to see current list of code numbers."), &disablelist
);
2718 add_cmd ("display", class_vars
, undisplay_command
, _("\
2719 Cancel some expressions to be displayed when program stops.\n\
2720 Usage: delete display [NUM]...\n\
2721 Arguments are the code numbers of the expressions to stop displaying.\n\
2722 No argument means cancel all automatic-display expressions.\n\
2723 Do \"info display\" to see current list of code numbers."), &deletelist
);
2725 add_com ("printf", class_vars
, printf_command
, _("\
2726 Formatted printing, like the C \"printf\" function.\n\
2727 Usage: printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
2728 This supports most C printf format specifications, like %s, %d, etc."));
2730 add_com ("output", class_vars
, output_command
, _("\
2731 Like \"print\" but don't put in value history and don't print newline.\n\
2732 Usage: output EXP\n\
2733 This is useful in user-defined commands."));
2735 add_prefix_cmd ("set", class_vars
, set_command
, _("\
2736 Evaluate expression EXP and assign result to variable VAR\n\
2737 Usage: set VAR = EXP\n\
2738 This uses assignment syntax appropriate for the current language\n\
2739 (VAR = EXP or VAR := EXP for example).\n\
2740 VAR may be a debugger \"convenience\" variable (names starting\n\
2741 with $), a register (a few standard names starting with $), or an actual\n\
2742 variable in the program being debugged. EXP is any valid expression.\n\
2743 Use \"set variable\" for variables with names identical to set subcommands.\n\
2745 With a subcommand, this command modifies parts of the gdb environment.\n\
2746 You can see these environment settings with the \"show\" command."),
2747 &setlist
, "set ", 1, &cmdlist
);
2749 add_com ("assign", class_vars
, set_command
, _("\
2750 Evaluate expression EXP and assign result to variable VAR\n\
2751 Usage: assign VAR = EXP\n\
2752 This uses assignment syntax appropriate for the current language\n\
2753 (VAR = EXP or VAR := EXP for example).\n\
2754 VAR may be a debugger \"convenience\" variable (names starting\n\
2755 with $), a register (a few standard names starting with $), or an actual\n\
2756 variable in the program being debugged. EXP is any valid expression.\n\
2757 Use \"set variable\" for variables with names identical to set subcommands.\n\
2758 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2759 You can see these environment settings with the \"show\" command."));
2761 /* "call" is the same as "set", but handy for dbx users to call fns. */
2762 c
= add_com ("call", class_vars
, call_command
, _("\
2763 Call a function in the program.\n\
2765 The argument is the function name and arguments, in the notation of the\n\
2766 current working language. The result is printed and saved in the value\n\
2767 history, if it is not void."));
2768 set_cmd_completer (c
, expression_completer
);
2770 add_cmd ("variable", class_vars
, set_command
, _("\
2771 Evaluate expression EXP and assign result to variable VAR\n\
2772 Usage: set variable VAR = EXP\n\
2773 This uses assignment syntax appropriate for the current language\n\
2774 (VAR = EXP or VAR := EXP for example).\n\
2775 VAR may be a debugger \"convenience\" variable (names starting\n\
2776 with $), a register (a few standard names starting with $), or an actual\n\
2777 variable in the program being debugged. EXP is any valid expression.\n\
2778 This may usually be abbreviated to simply \"set\"."),
2780 add_alias_cmd ("var", "variable", class_vars
, 0, &setlist
);
2782 c
= add_com ("print", class_vars
, print_command
, _("\
2783 Print value of expression EXP.\n\
2784 Usage: print[/FMT] EXP\n\
2785 Variables accessible are those of the lexical environment of the selected\n\
2786 stack frame, plus all those whose scope is global or an entire file.\n\
2788 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2789 $$NUM refers to NUM'th value back from the last one.\n\
2790 Names starting with $ refer to registers (with the values they would have\n\
2791 if the program were to return to the stack frame now selected, restoring\n\
2792 all registers saved by frames farther in) or else to debugger\n\
2793 \"convenience\" variables (any such name not a known register).\n\
2794 Use assignment expressions to give values to convenience variables.\n\
2796 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2797 @ is a binary operator for treating consecutive data objects\n\
2798 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2799 element is FOO, whose second element is stored in the space following\n\
2800 where FOO is stored, etc. FOO must be an expression whose value\n\
2801 resides in memory.\n\
2803 EXP may be preceded with /FMT, where FMT is a format letter\n\
2804 but no count or size letter (see \"x\" command)."));
2805 set_cmd_completer (c
, expression_completer
);
2806 add_com_alias ("p", "print", class_vars
, 1);
2807 add_com_alias ("inspect", "print", class_vars
, 1);
2809 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class
,
2810 &max_symbolic_offset
, _("\
2811 Set the largest offset that will be printed in <SYMBOL+1234> form."), _("\
2812 Show the largest offset that will be printed in <SYMBOL+1234> form."), _("\
2813 Tell GDB to only display the symbolic form of an address if the\n\
2814 offset between the closest earlier symbol and the address is less than\n\
2815 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
2816 to always print the symbolic form of an address if any symbol precedes\n\
2817 it. Zero is equivalent to \"unlimited\"."),
2819 show_max_symbolic_offset
,
2820 &setprintlist
, &showprintlist
);
2821 add_setshow_boolean_cmd ("symbol-filename", no_class
,
2822 &print_symbol_filename
, _("\
2823 Set printing of source filename and line number with <SYMBOL>."), _("\
2824 Show printing of source filename and line number with <SYMBOL>."), NULL
,
2826 show_print_symbol_filename
,
2827 &setprintlist
, &showprintlist
);
2829 add_com ("eval", no_class
, eval_command
, _("\
2830 Construct a GDB command and then evaluate it.\n\
2831 Usage: eval \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
2832 Convert the arguments to a string as \"printf\" would, but then\n\
2833 treat this string as a command line, and evaluate it."));