1 /* Print values for GNU debugger GDB.
3 Copyright (C) 1986-2017 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 */
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"
54 #include "tui/tui.h" /* For tui_active et al. */
57 /* Last specified output format. */
59 static char last_format
= 0;
61 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
63 static char last_size
= 'w';
65 /* 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 struct value
*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 while (*p
== ' ' || *p
== '\t')
218 /* Set defaults for format and size if not specified. */
219 if (val
.format
== '?')
223 /* Neither has been specified. */
224 val
.format
= oformat
;
228 /* If a size is specified, any format makes a reasonable
229 default except 'i'. */
230 val
.format
= oformat
== 'i' ? 'x' : oformat
;
232 else if (val
.size
== '?')
236 /* Pick the appropriate size for an address. This is deferred
237 until do_examine when we know the actual architecture to use.
238 A special size value of 'a' is used to indicate this case. */
239 val
.size
= osize
? 'a' : osize
;
242 /* Floating point has to be word or giantword. */
243 if (osize
== 'w' || osize
== 'g')
246 /* Default it to giantword if the last used size is not
248 val
.size
= osize
? 'g' : osize
;
251 /* Characters default to one byte. */
252 val
.size
= osize
? 'b' : osize
;
255 /* Display strings with byte size chars unless explicitly
261 /* The default is the size most recently specified. */
268 /* Print value VAL on stream according to OPTIONS.
269 Do not end with a newline.
270 SIZE is the letter for the size of datum being printed.
271 This is used to pad hex numbers so they line up. SIZE is 0
272 for print / output and set for examine. */
275 print_formatted (struct value
*val
, int size
,
276 const struct value_print_options
*options
,
277 struct ui_file
*stream
)
279 struct type
*type
= check_typedef (value_type (val
));
280 int len
= TYPE_LENGTH (type
);
282 if (VALUE_LVAL (val
) == lval_memory
)
283 next_address
= value_address (val
) + len
;
287 switch (options
->format
)
291 struct type
*elttype
= value_type (val
);
293 next_address
= (value_address (val
)
294 + val_print_string (elttype
, NULL
,
295 value_address (val
), -1,
296 stream
, options
) * len
);
301 /* We often wrap here if there are long symbolic names. */
303 next_address
= (value_address (val
)
304 + gdb_print_insn (get_type_arch (type
),
305 value_address (val
), stream
,
306 &branch_delay_insns
));
311 if (options
->format
== 0 || options
->format
== 's'
312 || TYPE_CODE (type
) == TYPE_CODE_REF
313 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
314 || TYPE_CODE (type
) == TYPE_CODE_STRING
315 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
316 || TYPE_CODE (type
) == TYPE_CODE_UNION
317 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
318 value_print (val
, stream
, options
);
320 /* User specified format, so don't look to the type to tell us
322 val_print_scalar_formatted (type
,
323 value_embedded_offset (val
),
325 options
, size
, stream
);
328 /* Return builtin floating point type of same length as TYPE.
329 If no such type is found, return TYPE itself. */
331 float_type_from_length (struct type
*type
)
333 struct gdbarch
*gdbarch
= get_type_arch (type
);
334 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
336 if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_float
))
337 type
= builtin
->builtin_float
;
338 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_double
))
339 type
= builtin
->builtin_double
;
340 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_long_double
))
341 type
= builtin
->builtin_long_double
;
346 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
347 according to OPTIONS and SIZE on STREAM. Formats s and i are not
348 supported at this level. */
351 print_scalar_formatted (const gdb_byte
*valaddr
, struct type
*type
,
352 const struct value_print_options
*options
,
353 int size
, struct ui_file
*stream
)
355 struct gdbarch
*gdbarch
= get_type_arch (type
);
356 unsigned int len
= TYPE_LENGTH (type
);
357 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
359 /* String printing should go through val_print_scalar_formatted. */
360 gdb_assert (options
->format
!= 's');
362 /* If the value is a pointer, and pointers and addresses are not the
363 same, then at this point, the value's length (in target bytes) is
364 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
365 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
366 len
= gdbarch_addr_bit (gdbarch
) / TARGET_CHAR_BIT
;
368 /* If we are printing it as unsigned, truncate it in case it is actually
369 a negative signed value (e.g. "print/u (short)-1" should print 65535
370 (if shorts are 16 bits) instead of 4294967295). */
371 if (options
->format
!= 'c'
372 && (options
->format
!= 'd' || TYPE_UNSIGNED (type
)))
374 if (len
< TYPE_LENGTH (type
) && byte_order
== BFD_ENDIAN_BIG
)
375 valaddr
+= TYPE_LENGTH (type
) - len
;
378 if (size
!= 0 && (options
->format
== 'x' || options
->format
== 't'))
380 /* Truncate to fit. */
397 error (_("Undefined output size \"%c\"."), size
);
399 if (newlen
< len
&& byte_order
== BFD_ENDIAN_BIG
)
400 valaddr
+= len
- newlen
;
404 /* Historically gdb has printed floats by first casting them to a
405 long, and then printing the long. PR cli/16242 suggests changing
406 this to using C-style hex float format. */
407 gdb::byte_vector converted_float_bytes
;
408 if (TYPE_CODE (type
) == TYPE_CODE_FLT
409 && (options
->format
== 'o'
410 || options
->format
== 'x'
411 || options
->format
== 't'
412 || options
->format
== 'z'
413 || options
->format
== 'd'
414 || options
->format
== 'u'))
416 LONGEST val_long
= unpack_long (type
, valaddr
);
417 converted_float_bytes
.resize (TYPE_LENGTH (type
));
418 store_signed_integer (converted_float_bytes
.data (), TYPE_LENGTH (type
),
419 byte_order
, val_long
);
420 valaddr
= converted_float_bytes
.data ();
423 switch (options
->format
)
426 print_octal_chars (stream
, valaddr
, len
, byte_order
);
429 print_decimal_chars (stream
, valaddr
, len
, true, byte_order
);
432 print_decimal_chars (stream
, valaddr
, len
, false, byte_order
);
435 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
437 print_decimal_chars (stream
, valaddr
, len
, !TYPE_UNSIGNED (type
),
443 type
= float_type_from_length (type
);
444 print_floating (valaddr
, type
, stream
);
448 print_binary_chars (stream
, valaddr
, len
, byte_order
, size
> 0);
451 print_hex_chars (stream
, valaddr
, len
, byte_order
, size
> 0);
454 print_hex_chars (stream
, valaddr
, len
, byte_order
, true);
458 struct value_print_options opts
= *options
;
460 LONGEST val_long
= unpack_long (type
, valaddr
);
463 if (TYPE_UNSIGNED (type
))
464 type
= builtin_type (gdbarch
)->builtin_true_unsigned_char
;
466 type
= builtin_type (gdbarch
)->builtin_true_char
;
468 value_print (value_from_longest (type
, val_long
), stream
, &opts
);
474 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
476 print_address (gdbarch
, addr
, stream
);
481 error (_("Undefined output format \"%c\"."), options
->format
);
485 /* Specify default address for `x' command.
486 The `info lines' command uses this. */
489 set_next_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
491 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
493 next_gdbarch
= gdbarch
;
496 /* Make address available to the user as $_. */
497 set_internalvar (lookup_internalvar ("_"),
498 value_from_pointer (ptr_type
, addr
));
501 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
502 after LEADIN. Print nothing if no symbolic name is found nearby.
503 Optionally also print source file and line number, if available.
504 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
505 or to interpret it as a possible C++ name and convert it back to source
506 form. However note that DO_DEMANGLE can be overridden by the specific
507 settings of the demangle and asm_demangle variables. Returns
508 non-zero if anything was printed; zero otherwise. */
511 print_address_symbolic (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
512 struct ui_file
*stream
,
513 int do_demangle
, const char *leadin
)
516 char *filename
= NULL
;
521 /* Throw away both name and filename. */
522 struct cleanup
*cleanup_chain
= make_cleanup (free_current_contents
, &name
);
523 make_cleanup (free_current_contents
, &filename
);
525 if (build_address_symbolic (gdbarch
, addr
, do_demangle
, &name
, &offset
,
526 &filename
, &line
, &unmapped
))
528 do_cleanups (cleanup_chain
);
532 fputs_filtered (leadin
, stream
);
534 fputs_filtered ("<*", stream
);
536 fputs_filtered ("<", stream
);
537 fputs_filtered (name
, stream
);
539 fprintf_filtered (stream
, "+%u", (unsigned int) offset
);
541 /* Append source filename and line number if desired. Give specific
542 line # of this addr, if we have it; else line # of the nearest symbol. */
543 if (print_symbol_filename
&& filename
!= NULL
)
546 fprintf_filtered (stream
, " at %s:%d", filename
, line
);
548 fprintf_filtered (stream
, " in %s", filename
);
551 fputs_filtered ("*>", stream
);
553 fputs_filtered (">", stream
);
555 do_cleanups (cleanup_chain
);
559 /* Given an address ADDR return all the elements needed to print the
560 address in a symbolic form. NAME can be mangled or not depending
561 on DO_DEMANGLE (and also on the asm_demangle global variable,
562 manipulated via ''set print asm-demangle''). Return 0 in case of
563 success, when all the info in the OUT paramters is valid. Return 1
566 build_address_symbolic (struct gdbarch
*gdbarch
,
567 CORE_ADDR addr
, /* IN */
568 int do_demangle
, /* IN */
569 char **name
, /* OUT */
570 int *offset
, /* OUT */
571 char **filename
, /* OUT */
573 int *unmapped
) /* OUT */
575 struct bound_minimal_symbol msymbol
;
576 struct symbol
*symbol
;
577 CORE_ADDR name_location
= 0;
578 struct obj_section
*section
= NULL
;
579 const char *name_temp
= "";
581 /* Let's say it is mapped (not unmapped). */
584 /* Determine if the address is in an overlay, and whether it is
586 if (overlay_debugging
)
588 section
= find_pc_overlay (addr
);
589 if (pc_in_unmapped_range (addr
, section
))
592 addr
= overlay_mapped_address (addr
, section
);
596 /* First try to find the address in the symbol table, then
597 in the minsyms. Take the closest one. */
599 /* This is defective in the sense that it only finds text symbols. So
600 really this is kind of pointless--we should make sure that the
601 minimal symbols have everything we need (by changing that we could
602 save some memory, but for many debug format--ELF/DWARF or
603 anything/stabs--it would be inconvenient to eliminate those minimal
605 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
606 symbol
= find_pc_sect_function (addr
, section
);
610 /* If this is a function (i.e. a code address), strip out any
611 non-address bits. For instance, display a pointer to the
612 first instruction of a Thumb function as <function>; the
613 second instruction will be <function+2>, even though the
614 pointer is <function+3>. This matches the ISA behavior. */
615 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
617 name_location
= BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
));
618 if (do_demangle
|| asm_demangle
)
619 name_temp
= SYMBOL_PRINT_NAME (symbol
);
621 name_temp
= SYMBOL_LINKAGE_NAME (symbol
);
624 if (msymbol
.minsym
!= NULL
625 && MSYMBOL_HAS_SIZE (msymbol
.minsym
)
626 && MSYMBOL_SIZE (msymbol
.minsym
) == 0
627 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text
628 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text_gnu_ifunc
629 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_file_text
)
630 msymbol
.minsym
= NULL
;
632 if (msymbol
.minsym
!= NULL
)
634 if (BMSYMBOL_VALUE_ADDRESS (msymbol
) > name_location
|| symbol
== NULL
)
636 /* If this is a function (i.e. a code address), strip out any
637 non-address bits. For instance, display a pointer to the
638 first instruction of a Thumb function as <function>; the
639 second instruction will be <function+2>, even though the
640 pointer is <function+3>. This matches the ISA behavior. */
641 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_text
642 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_text_gnu_ifunc
643 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_text
644 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
645 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
647 /* The msymbol is closer to the address than the symbol;
648 use the msymbol instead. */
650 name_location
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
651 if (do_demangle
|| asm_demangle
)
652 name_temp
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
654 name_temp
= MSYMBOL_LINKAGE_NAME (msymbol
.minsym
);
657 if (symbol
== NULL
&& msymbol
.minsym
== NULL
)
660 /* If the nearest symbol is too far away, don't print anything symbolic. */
662 /* For when CORE_ADDR is larger than unsigned int, we do math in
663 CORE_ADDR. But when we detect unsigned wraparound in the
664 CORE_ADDR math, we ignore this test and print the offset,
665 because addr+max_symbolic_offset has wrapped through the end
666 of the address space back to the beginning, giving bogus comparison. */
667 if (addr
> name_location
+ max_symbolic_offset
668 && name_location
+ max_symbolic_offset
> name_location
)
671 *offset
= addr
- name_location
;
673 *name
= xstrdup (name_temp
);
675 if (print_symbol_filename
)
677 struct symtab_and_line sal
;
679 sal
= find_pc_sect_line (addr
, section
, 0);
683 *filename
= xstrdup (symtab_to_filename_for_display (sal
.symtab
));
691 /* Print address ADDR symbolically on STREAM.
692 First print it as a number. Then perhaps print
693 <SYMBOL + OFFSET> after the number. */
696 print_address (struct gdbarch
*gdbarch
,
697 CORE_ADDR addr
, struct ui_file
*stream
)
699 fputs_filtered (paddress (gdbarch
, addr
), stream
);
700 print_address_symbolic (gdbarch
, addr
, stream
, asm_demangle
, " ");
703 /* Return a prefix for instruction address:
704 "=> " for current instruction, else " ". */
707 pc_prefix (CORE_ADDR addr
)
709 if (has_stack_frames ())
711 struct frame_info
*frame
;
714 frame
= get_selected_frame (NULL
);
715 if (get_frame_pc_if_available (frame
, &pc
) && pc
== addr
)
721 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
722 controls whether to print the symbolic name "raw" or demangled.
723 Return non-zero if anything was printed; zero otherwise. */
726 print_address_demangle (const struct value_print_options
*opts
,
727 struct gdbarch
*gdbarch
, CORE_ADDR addr
,
728 struct ui_file
*stream
, int do_demangle
)
730 if (opts
->addressprint
)
732 fputs_filtered (paddress (gdbarch
, addr
), stream
);
733 print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, " ");
737 return print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, "");
743 /* Find the address of the instruction that is INST_COUNT instructions before
744 the instruction at ADDR.
745 Since some architectures have variable-length instructions, we can't just
746 simply subtract INST_COUNT * INSN_LEN from ADDR. Instead, we use line
747 number information to locate the nearest known instruction boundary,
748 and disassemble forward from there. If we go out of the symbol range
749 during disassembling, we return the lowest address we've got so far and
750 set the number of instructions read to INST_READ. */
753 find_instruction_backward (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
754 int inst_count
, int *inst_read
)
756 /* The vector PCS is used to store instruction addresses within
758 CORE_ADDR loop_start
, loop_end
, p
;
759 std::vector
<CORE_ADDR
> pcs
;
760 struct symtab_and_line sal
;
763 loop_start
= loop_end
= addr
;
765 /* In each iteration of the outer loop, we get a pc range that ends before
766 LOOP_START, then we count and store every instruction address of the range
767 iterated in the loop.
768 If the number of instructions counted reaches INST_COUNT, return the
769 stored address that is located INST_COUNT instructions back from ADDR.
770 If INST_COUNT is not reached, we subtract the number of counted
771 instructions from INST_COUNT, and go to the next iteration. */
775 sal
= find_pc_sect_line (loop_start
, NULL
, 1);
778 /* We reach here when line info is not available. In this case,
779 we print a message and just exit the loop. The return value
780 is calculated after the loop. */
781 printf_filtered (_("No line number information available "
784 print_address (gdbarch
, loop_start
- 1, gdb_stdout
);
785 printf_filtered ("\n");
789 loop_end
= loop_start
;
792 /* This loop pushes instruction addresses in the range from
793 LOOP_START to LOOP_END. */
794 for (p
= loop_start
; p
< loop_end
;)
797 p
+= gdb_insn_length (gdbarch
, p
);
800 inst_count
-= pcs
.size ();
801 *inst_read
+= pcs
.size ();
803 while (inst_count
> 0);
805 /* After the loop, the vector PCS has instruction addresses of the last
806 source line we processed, and INST_COUNT has a negative value.
807 We return the address at the index of -INST_COUNT in the vector for
809 Let's assume the following instruction addresses and run 'x/-4i 0x400e'.
819 find_instruction_backward is called with INST_COUNT = 4 and expected to
820 return 0x4001. When we reach here, INST_COUNT is set to -1 because
821 it was subtracted by 2 (from Line Y) and 3 (from Line X). The value
822 4001 is located at the index 1 of the last iterated line (= Line X),
823 which is simply calculated by -INST_COUNT.
824 The case when the length of PCS is 0 means that we reached an area for
825 which line info is not available. In such case, we return LOOP_START,
826 which was the lowest instruction address that had line info. */
827 p
= pcs
.size () > 0 ? pcs
[-inst_count
] : loop_start
;
829 /* INST_READ includes all instruction addresses in a pc range. Need to
830 exclude the beginning part up to the address we're returning. That
831 is, exclude {0x4000} in the example above. */
833 *inst_read
+= inst_count
;
838 /* Backward read LEN bytes of target memory from address MEMADDR + LEN,
839 placing the results in GDB's memory from MYADDR + LEN. Returns
840 a count of the bytes actually read. */
843 read_memory_backward (struct gdbarch
*gdbarch
,
844 CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
847 int nread
; /* Number of bytes actually read. */
849 /* First try a complete read. */
850 errcode
= target_read_memory (memaddr
, myaddr
, len
);
858 /* Loop, reading one byte at a time until we get as much as we can. */
861 for (nread
= 0; nread
< len
; ++nread
)
863 errcode
= target_read_memory (--memaddr
, --myaddr
, 1);
866 /* The read was unsuccessful, so exit the loop. */
867 printf_filtered (_("Cannot access memory at address %s\n"),
868 paddress (gdbarch
, memaddr
));
876 /* Returns true if X (which is LEN bytes wide) is the number zero. */
879 integer_is_zero (const gdb_byte
*x
, int len
)
883 while (i
< len
&& x
[i
] == 0)
888 /* Find the start address of a string in which ADDR is included.
889 Basically we search for '\0' and return the next address,
890 but if OPTIONS->PRINT_MAX is smaller than the length of a string,
891 we stop searching and return the address to print characters as many as
892 PRINT_MAX from the string. */
895 find_string_backward (struct gdbarch
*gdbarch
,
896 CORE_ADDR addr
, int count
, int char_size
,
897 const struct value_print_options
*options
,
898 int *strings_counted
)
900 const int chunk_size
= 0x20;
903 int chars_to_read
= chunk_size
;
904 int chars_counted
= 0;
905 int count_original
= count
;
906 CORE_ADDR string_start_addr
= addr
;
908 gdb_assert (char_size
== 1 || char_size
== 2 || char_size
== 4);
909 gdb::byte_vector
buffer (chars_to_read
* char_size
);
910 while (count
> 0 && read_error
== 0)
914 addr
-= chars_to_read
* char_size
;
915 chars_read
= read_memory_backward (gdbarch
, addr
, buffer
.data (),
916 chars_to_read
* char_size
);
917 chars_read
/= char_size
;
918 read_error
= (chars_read
== chars_to_read
) ? 0 : 1;
919 /* Searching for '\0' from the end of buffer in backward direction. */
920 for (i
= 0; i
< chars_read
&& count
> 0 ; ++i
, ++chars_counted
)
922 int offset
= (chars_to_read
- i
- 1) * char_size
;
924 if (integer_is_zero (&buffer
[offset
], char_size
)
925 || chars_counted
== options
->print_max
)
927 /* Found '\0' or reached print_max. As OFFSET is the offset to
928 '\0', we add CHAR_SIZE to return the start address of
931 string_start_addr
= addr
+ offset
+ char_size
;
937 /* Update STRINGS_COUNTED with the actual number of loaded strings. */
938 *strings_counted
= count_original
- count
;
942 /* In error case, STRING_START_ADDR is pointing to the string that
943 was last successfully loaded. Rewind the partially loaded string. */
944 string_start_addr
-= chars_counted
* char_size
;
947 return string_start_addr
;
950 /* Examine data at address ADDR in format FMT.
951 Fetch it from memory and print on gdb_stdout. */
954 do_examine (struct format_data fmt
, struct gdbarch
*gdbarch
, CORE_ADDR addr
)
959 struct type
*val_type
= NULL
;
962 struct value_print_options opts
;
963 int need_to_update_next_address
= 0;
964 CORE_ADDR addr_rewound
= 0;
969 next_gdbarch
= gdbarch
;
972 /* Instruction format implies fetch single bytes
973 regardless of the specified size.
974 The case of strings is handled in decode_format, only explicit
975 size operator are not changed to 'b'. */
981 /* Pick the appropriate size for an address. */
982 if (gdbarch_ptr_bit (next_gdbarch
) == 64)
984 else if (gdbarch_ptr_bit (next_gdbarch
) == 32)
986 else if (gdbarch_ptr_bit (next_gdbarch
) == 16)
989 /* Bad value for gdbarch_ptr_bit. */
990 internal_error (__FILE__
, __LINE__
,
991 _("failed internal consistency check"));
995 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
996 else if (size
== 'h')
997 val_type
= builtin_type (next_gdbarch
)->builtin_int16
;
998 else if (size
== 'w')
999 val_type
= builtin_type (next_gdbarch
)->builtin_int32
;
1000 else if (size
== 'g')
1001 val_type
= builtin_type (next_gdbarch
)->builtin_int64
;
1005 struct type
*char_type
= NULL
;
1007 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
1008 if type is not found. */
1010 char_type
= builtin_type (next_gdbarch
)->builtin_char16
;
1011 else if (size
== 'w')
1012 char_type
= builtin_type (next_gdbarch
)->builtin_char32
;
1014 val_type
= char_type
;
1017 if (size
!= '\0' && size
!= 'b')
1018 warning (_("Unable to display strings with "
1019 "size '%c', using 'b' instead."), size
);
1021 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1030 if (format
== 's' || format
== 'i')
1033 get_formatted_print_options (&opts
, format
);
1037 /* This is the negative repeat count case.
1038 We rewind the address based on the given repeat count and format,
1039 then examine memory from there in forward direction. */
1044 next_address
= find_instruction_backward (gdbarch
, addr
, count
,
1047 else if (format
== 's')
1049 next_address
= find_string_backward (gdbarch
, addr
, count
,
1050 TYPE_LENGTH (val_type
),
1055 next_address
= addr
- count
* TYPE_LENGTH (val_type
);
1058 /* The following call to print_formatted updates next_address in every
1059 iteration. In backward case, we store the start address here
1060 and update next_address with it before exiting the function. */
1061 addr_rewound
= (format
== 's'
1062 ? next_address
- TYPE_LENGTH (val_type
)
1064 need_to_update_next_address
= 1;
1067 /* Print as many objects as specified in COUNT, at most maxelts per line,
1068 with the address of the next one at the start of each line. */
1074 fputs_filtered (pc_prefix (next_address
), gdb_stdout
);
1075 print_address (next_gdbarch
, next_address
, gdb_stdout
);
1076 printf_filtered (":");
1081 printf_filtered ("\t");
1082 /* Note that print_formatted sets next_address for the next
1084 last_examine_address
= next_address
;
1086 if (last_examine_value
)
1087 value_free (last_examine_value
);
1089 /* The value to be displayed is not fetched greedily.
1090 Instead, to avoid the possibility of a fetched value not
1091 being used, its retrieval is delayed until the print code
1092 uses it. When examining an instruction stream, the
1093 disassembler will perform its own memory fetch using just
1094 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
1095 the disassembler be modified so that LAST_EXAMINE_VALUE
1096 is left with the byte sequence from the last complete
1097 instruction fetched from memory? */
1098 last_examine_value
= value_at_lazy (val_type
, next_address
);
1100 if (last_examine_value
)
1101 release_value (last_examine_value
);
1103 print_formatted (last_examine_value
, size
, &opts
, gdb_stdout
);
1105 /* Display any branch delay slots following the final insn. */
1106 if (format
== 'i' && count
== 1)
1107 count
+= branch_delay_insns
;
1109 printf_filtered ("\n");
1110 gdb_flush (gdb_stdout
);
1113 if (need_to_update_next_address
)
1114 next_address
= addr_rewound
;
1118 validate_format (struct format_data fmt
, const char *cmdname
)
1121 error (_("Size letters are meaningless in \"%s\" command."), cmdname
);
1123 error (_("Item count other than 1 is meaningless in \"%s\" command."),
1125 if (fmt
.format
== 'i')
1126 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
1127 fmt
.format
, cmdname
);
1130 /* Parse print command format string into *FMTP and update *EXPP.
1131 CMDNAME should name the current command. */
1134 print_command_parse_format (const char **expp
, const char *cmdname
,
1135 struct format_data
*fmtp
)
1137 const char *exp
= *expp
;
1139 if (exp
&& *exp
== '/')
1142 *fmtp
= decode_format (&exp
, last_format
, 0);
1143 validate_format (*fmtp
, cmdname
);
1144 last_format
= fmtp
->format
;
1157 /* Print VAL to console according to *FMTP, including recording it to
1161 print_value (struct value
*val
, const struct format_data
*fmtp
)
1163 struct value_print_options opts
;
1164 int histindex
= record_latest_value (val
);
1166 annotate_value_history_begin (histindex
, value_type (val
));
1168 printf_filtered ("$%d = ", histindex
);
1170 annotate_value_history_value ();
1172 get_formatted_print_options (&opts
, fmtp
->format
);
1173 opts
.raw
= fmtp
->raw
;
1175 print_formatted (val
, fmtp
->size
, &opts
, gdb_stdout
);
1176 printf_filtered ("\n");
1178 annotate_value_history_end ();
1181 /* Evaluate string EXP as an expression in the current language and
1182 print the resulting value. EXP may contain a format specifier as the
1183 first argument ("/x myvar" for example, to print myvar in hex). */
1186 print_command_1 (const char *exp
, int voidprint
)
1189 struct format_data fmt
;
1191 print_command_parse_format (&exp
, "print", &fmt
);
1195 expression_up expr
= parse_expression (exp
);
1196 val
= evaluate_expression (expr
.get ());
1199 val
= access_value_history (0);
1201 if (voidprint
|| (val
&& value_type (val
) &&
1202 TYPE_CODE (value_type (val
)) != TYPE_CODE_VOID
))
1203 print_value (val
, &fmt
);
1207 print_command (char *exp
, int from_tty
)
1209 print_command_1 (exp
, 1);
1212 /* Same as print, except it doesn't print void results. */
1214 call_command (char *exp
, int from_tty
)
1216 print_command_1 (exp
, 0);
1219 /* Implementation of the "output" command. */
1222 output_command (char *exp
, int from_tty
)
1224 output_command_const (exp
, from_tty
);
1227 /* Like output_command, but takes a const string as argument. */
1230 output_command_const (const char *exp
, int from_tty
)
1234 struct format_data fmt
;
1235 struct value_print_options opts
;
1240 if (exp
&& *exp
== '/')
1243 fmt
= decode_format (&exp
, 0, 0);
1244 validate_format (fmt
, "output");
1245 format
= fmt
.format
;
1248 expression_up expr
= parse_expression (exp
);
1250 val
= evaluate_expression (expr
.get ());
1252 annotate_value_begin (value_type (val
));
1254 get_formatted_print_options (&opts
, format
);
1256 print_formatted (val
, fmt
.size
, &opts
, gdb_stdout
);
1258 annotate_value_end ();
1261 gdb_flush (gdb_stdout
);
1265 set_command (char *exp
, int from_tty
)
1267 expression_up expr
= parse_expression (exp
);
1269 if (expr
->nelts
>= 1)
1270 switch (expr
->elts
[0].opcode
)
1272 case UNOP_PREINCREMENT
:
1273 case UNOP_POSTINCREMENT
:
1274 case UNOP_PREDECREMENT
:
1275 case UNOP_POSTDECREMENT
:
1277 case BINOP_ASSIGN_MODIFY
:
1282 (_("Expression is not an assignment (and might have no effect)"));
1285 evaluate_expression (expr
.get ());
1289 info_symbol_command (char *arg
, int from_tty
)
1291 struct minimal_symbol
*msymbol
;
1292 struct objfile
*objfile
;
1293 struct obj_section
*osect
;
1294 CORE_ADDR addr
, sect_addr
;
1296 unsigned int offset
;
1299 error_no_arg (_("address"));
1301 addr
= parse_and_eval_address (arg
);
1302 ALL_OBJSECTIONS (objfile
, osect
)
1304 /* Only process each object file once, even if there's a separate
1306 if (objfile
->separate_debug_objfile_backlink
)
1309 sect_addr
= overlay_mapped_address (addr
, osect
);
1311 if (obj_section_addr (osect
) <= sect_addr
1312 && sect_addr
< obj_section_endaddr (osect
)
1314 = lookup_minimal_symbol_by_pc_section (sect_addr
, osect
).minsym
))
1316 const char *obj_name
, *mapped
, *sec_name
, *msym_name
;
1317 const char *loc_string
;
1318 struct cleanup
*old_chain
;
1321 offset
= sect_addr
- MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
);
1322 mapped
= section_is_mapped (osect
) ? _("mapped") : _("unmapped");
1323 sec_name
= osect
->the_bfd_section
->name
;
1324 msym_name
= MSYMBOL_PRINT_NAME (msymbol
);
1326 /* Don't print the offset if it is zero.
1327 We assume there's no need to handle i18n of "sym + offset". */
1328 std::string string_holder
;
1331 string_holder
= string_printf ("%s + %u", msym_name
, offset
);
1332 loc_string
= string_holder
.c_str ();
1335 loc_string
= msym_name
;
1337 gdb_assert (osect
->objfile
&& objfile_name (osect
->objfile
));
1338 obj_name
= objfile_name (osect
->objfile
);
1340 if (MULTI_OBJFILE_P ())
1341 if (pc_in_unmapped_range (addr
, osect
))
1342 if (section_is_overlay (osect
))
1343 printf_filtered (_("%s in load address range of "
1344 "%s overlay section %s of %s\n"),
1345 loc_string
, mapped
, sec_name
, obj_name
);
1347 printf_filtered (_("%s in load address range of "
1348 "section %s of %s\n"),
1349 loc_string
, sec_name
, obj_name
);
1351 if (section_is_overlay (osect
))
1352 printf_filtered (_("%s in %s overlay section %s of %s\n"),
1353 loc_string
, mapped
, sec_name
, obj_name
);
1355 printf_filtered (_("%s in section %s of %s\n"),
1356 loc_string
, sec_name
, obj_name
);
1358 if (pc_in_unmapped_range (addr
, osect
))
1359 if (section_is_overlay (osect
))
1360 printf_filtered (_("%s in load address range of %s overlay "
1362 loc_string
, mapped
, sec_name
);
1364 printf_filtered (_("%s in load address range of section %s\n"),
1365 loc_string
, sec_name
);
1367 if (section_is_overlay (osect
))
1368 printf_filtered (_("%s in %s overlay section %s\n"),
1369 loc_string
, mapped
, sec_name
);
1371 printf_filtered (_("%s in section %s\n"),
1372 loc_string
, sec_name
);
1376 printf_filtered (_("No symbol matches %s.\n"), arg
);
1380 info_address_command (char *exp
, int from_tty
)
1382 struct gdbarch
*gdbarch
;
1385 struct bound_minimal_symbol msymbol
;
1387 struct obj_section
*section
;
1388 CORE_ADDR load_addr
, context_pc
= 0;
1389 struct field_of_this_result is_a_field_of_this
;
1392 error (_("Argument required."));
1394 sym
= lookup_symbol (exp
, get_selected_block (&context_pc
), VAR_DOMAIN
,
1395 &is_a_field_of_this
).symbol
;
1398 if (is_a_field_of_this
.type
!= NULL
)
1400 printf_filtered ("Symbol \"");
1401 fprintf_symbol_filtered (gdb_stdout
, exp
,
1402 current_language
->la_language
, DMGL_ANSI
);
1403 printf_filtered ("\" is a field of the local class variable ");
1404 if (current_language
->la_language
== language_objc
)
1405 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1407 printf_filtered ("`this'\n");
1411 msymbol
= lookup_bound_minimal_symbol (exp
);
1413 if (msymbol
.minsym
!= NULL
)
1415 struct objfile
*objfile
= msymbol
.objfile
;
1417 gdbarch
= get_objfile_arch (objfile
);
1418 load_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
1420 printf_filtered ("Symbol \"");
1421 fprintf_symbol_filtered (gdb_stdout
, exp
,
1422 current_language
->la_language
, DMGL_ANSI
);
1423 printf_filtered ("\" is at ");
1424 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1425 printf_filtered (" in a file compiled without debugging");
1426 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
1427 if (section_is_overlay (section
))
1429 load_addr
= overlay_unmapped_address (load_addr
, section
);
1430 printf_filtered (",\n -- loaded at ");
1431 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1432 printf_filtered (" in overlay section %s",
1433 section
->the_bfd_section
->name
);
1435 printf_filtered (".\n");
1438 error (_("No symbol \"%s\" in current context."), exp
);
1442 printf_filtered ("Symbol \"");
1443 fprintf_symbol_filtered (gdb_stdout
, SYMBOL_PRINT_NAME (sym
),
1444 current_language
->la_language
, DMGL_ANSI
);
1445 printf_filtered ("\" is ");
1446 val
= SYMBOL_VALUE (sym
);
1447 if (SYMBOL_OBJFILE_OWNED (sym
))
1448 section
= SYMBOL_OBJ_SECTION (symbol_objfile (sym
), sym
);
1451 gdbarch
= symbol_arch (sym
);
1453 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
1455 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, context_pc
,
1457 printf_filtered (".\n");
1461 switch (SYMBOL_CLASS (sym
))
1464 case LOC_CONST_BYTES
:
1465 printf_filtered ("constant");
1469 printf_filtered ("a label at address ");
1470 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1471 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1472 if (section_is_overlay (section
))
1474 load_addr
= overlay_unmapped_address (load_addr
, section
);
1475 printf_filtered (",\n -- loaded at ");
1476 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1477 printf_filtered (" in overlay section %s",
1478 section
->the_bfd_section
->name
);
1483 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
1486 /* GDBARCH is the architecture associated with the objfile the symbol
1487 is defined in; the target architecture may be different, and may
1488 provide additional registers. However, we do not know the target
1489 architecture at this point. We assume the objfile architecture
1490 will contain all the standard registers that occur in debug info
1492 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1494 if (SYMBOL_IS_ARGUMENT (sym
))
1495 printf_filtered (_("an argument in register %s"),
1496 gdbarch_register_name (gdbarch
, regno
));
1498 printf_filtered (_("a variable in register %s"),
1499 gdbarch_register_name (gdbarch
, regno
));
1503 printf_filtered (_("static storage at address "));
1504 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1505 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1506 if (section_is_overlay (section
))
1508 load_addr
= overlay_unmapped_address (load_addr
, section
);
1509 printf_filtered (_(",\n -- loaded at "));
1510 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1511 printf_filtered (_(" in overlay section %s"),
1512 section
->the_bfd_section
->name
);
1516 case LOC_REGPARM_ADDR
:
1517 /* Note comment at LOC_REGISTER. */
1518 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1519 printf_filtered (_("address of an argument in register %s"),
1520 gdbarch_register_name (gdbarch
, regno
));
1524 printf_filtered (_("an argument at offset %ld"), val
);
1528 printf_filtered (_("a local variable at frame offset %ld"), val
);
1532 printf_filtered (_("a reference argument at offset %ld"), val
);
1536 printf_filtered (_("a typedef"));
1540 printf_filtered (_("a function at address "));
1541 load_addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1542 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1543 if (section_is_overlay (section
))
1545 load_addr
= overlay_unmapped_address (load_addr
, section
);
1546 printf_filtered (_(",\n -- loaded at "));
1547 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1548 printf_filtered (_(" in overlay section %s"),
1549 section
->the_bfd_section
->name
);
1553 case LOC_UNRESOLVED
:
1555 struct bound_minimal_symbol msym
;
1557 msym
= lookup_minimal_symbol_and_objfile (SYMBOL_LINKAGE_NAME (sym
));
1558 if (msym
.minsym
== NULL
)
1559 printf_filtered ("unresolved");
1562 section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
1565 && (section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
1567 load_addr
= MSYMBOL_VALUE_RAW_ADDRESS (msym
.minsym
);
1568 printf_filtered (_("a thread-local variable at offset %s "
1569 "in the thread-local storage for `%s'"),
1570 paddress (gdbarch
, load_addr
),
1571 objfile_name (section
->objfile
));
1575 load_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
1576 printf_filtered (_("static storage at address "));
1577 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1578 if (section_is_overlay (section
))
1580 load_addr
= overlay_unmapped_address (load_addr
, section
);
1581 printf_filtered (_(",\n -- loaded at "));
1582 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1583 printf_filtered (_(" in overlay section %s"),
1584 section
->the_bfd_section
->name
);
1591 case LOC_OPTIMIZED_OUT
:
1592 printf_filtered (_("optimized out"));
1596 printf_filtered (_("of unknown (botched) type"));
1599 printf_filtered (".\n");
1604 x_command (char *exp
, int from_tty
)
1606 struct format_data fmt
;
1609 fmt
.format
= last_format
? last_format
: 'x';
1610 fmt
.size
= last_size
;
1614 if (exp
&& *exp
== '/')
1616 const char *tmp
= exp
+ 1;
1618 fmt
= decode_format (&tmp
, last_format
, last_size
);
1622 /* If we have an expression, evaluate it and use it as the address. */
1624 if (exp
!= 0 && *exp
!= 0)
1626 expression_up expr
= parse_expression (exp
);
1627 /* Cause expression not to be there any more if this command is
1628 repeated with Newline. But don't clobber a user-defined
1629 command's definition. */
1632 val
= evaluate_expression (expr
.get ());
1633 if (TYPE_IS_REFERENCE (value_type (val
)))
1634 val
= coerce_ref (val
);
1635 /* In rvalue contexts, such as this, functions are coerced into
1636 pointers to functions. This makes "x/i main" work. */
1637 if (/* last_format == 'i' && */
1638 TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
1639 && VALUE_LVAL (val
) == lval_memory
)
1640 next_address
= value_address (val
);
1642 next_address
= value_as_address (val
);
1644 next_gdbarch
= expr
->gdbarch
;
1648 error_no_arg (_("starting display address"));
1650 do_examine (fmt
, next_gdbarch
, next_address
);
1652 /* If the examine succeeds, we remember its size and format for next
1653 time. Set last_size to 'b' for strings. */
1654 if (fmt
.format
== 's')
1657 last_size
= fmt
.size
;
1658 last_format
= fmt
.format
;
1660 /* Set a couple of internal variables if appropriate. */
1661 if (last_examine_value
)
1663 /* Make last address examined available to the user as $_. Use
1664 the correct pointer type. */
1665 struct type
*pointer_type
1666 = lookup_pointer_type (value_type (last_examine_value
));
1667 set_internalvar (lookup_internalvar ("_"),
1668 value_from_pointer (pointer_type
,
1669 last_examine_address
));
1671 /* Make contents of last address examined available to the user
1672 as $__. If the last value has not been fetched from memory
1673 then don't fetch it now; instead mark it by voiding the $__
1675 if (value_lazy (last_examine_value
))
1676 clear_internalvar (lookup_internalvar ("__"));
1678 set_internalvar (lookup_internalvar ("__"), last_examine_value
);
1683 /* Add an expression to the auto-display chain.
1684 Specify the expression. */
1687 display_command (char *arg
, int from_tty
)
1689 struct format_data fmt
;
1690 struct display
*newobj
;
1691 const char *exp
= arg
;
1702 fmt
= decode_format (&exp
, 0, 0);
1703 if (fmt
.size
&& fmt
.format
== 0)
1705 if (fmt
.format
== 'i' || fmt
.format
== 's')
1716 innermost_block
= NULL
;
1717 expression_up expr
= parse_expression (exp
);
1719 newobj
= new display ();
1721 newobj
->exp_string
= xstrdup (exp
);
1722 newobj
->exp
= std::move (expr
);
1723 newobj
->block
= innermost_block
;
1724 newobj
->pspace
= current_program_space
;
1725 newobj
->number
= ++display_number
;
1726 newobj
->format
= fmt
;
1727 newobj
->enabled_p
= 1;
1728 newobj
->next
= NULL
;
1730 if (display_chain
== NULL
)
1731 display_chain
= newobj
;
1734 struct display
*last
;
1736 for (last
= display_chain
; last
->next
!= NULL
; last
= last
->next
)
1738 last
->next
= newobj
;
1742 do_one_display (newobj
);
1748 free_display (struct display
*d
)
1750 xfree (d
->exp_string
);
1754 /* Clear out the display_chain. Done when new symtabs are loaded,
1755 since this invalidates the types stored in many expressions. */
1758 clear_displays (void)
1762 while ((d
= display_chain
) != NULL
)
1764 display_chain
= d
->next
;
1769 /* Delete the auto-display DISPLAY. */
1772 delete_display (struct display
*display
)
1776 gdb_assert (display
!= NULL
);
1778 if (display_chain
== display
)
1779 display_chain
= display
->next
;
1782 if (d
->next
== display
)
1784 d
->next
= display
->next
;
1788 free_display (display
);
1791 /* Call FUNCTION on each of the displays whose numbers are given in
1792 ARGS. DATA is passed unmodified to FUNCTION. */
1795 map_display_numbers (const char *args
,
1796 void (*function
) (struct display
*,
1803 error_no_arg (_("one or more display numbers"));
1805 number_or_range_parser
parser (args
);
1807 while (!parser
.finished ())
1809 const char *p
= parser
.cur_tok ();
1811 num
= parser
.get_number ();
1813 warning (_("bad display number at or near '%s'"), p
);
1816 struct display
*d
, *tmp
;
1818 ALL_DISPLAYS_SAFE (d
, tmp
)
1819 if (d
->number
== num
)
1822 printf_unfiltered (_("No display number %d.\n"), num
);
1829 /* Callback for map_display_numbers, that deletes a display. */
1832 do_delete_display (struct display
*d
, void *data
)
1837 /* "undisplay" command. */
1840 undisplay_command (const char *args
, int from_tty
)
1844 if (query (_("Delete all auto-display expressions? ")))
1850 map_display_numbers (args
, do_delete_display
, NULL
);
1854 /* Display a single auto-display.
1855 Do nothing if the display cannot be printed in the current context,
1856 or if the display is disabled. */
1859 do_one_display (struct display
*d
)
1861 int within_current_scope
;
1863 if (d
->enabled_p
== 0)
1866 /* The expression carries the architecture that was used at parse time.
1867 This is a problem if the expression depends on architecture features
1868 (e.g. register numbers), and the current architecture is now different.
1869 For example, a display statement like "display/i $pc" is expected to
1870 display the PC register of the current architecture, not the arch at
1871 the time the display command was given. Therefore, we re-parse the
1872 expression if the current architecture has changed. */
1873 if (d
->exp
!= NULL
&& d
->exp
->gdbarch
!= get_current_arch ())
1884 innermost_block
= NULL
;
1885 d
->exp
= parse_expression (d
->exp_string
);
1886 d
->block
= innermost_block
;
1888 CATCH (ex
, RETURN_MASK_ALL
)
1890 /* Can't re-parse the expression. Disable this display item. */
1892 warning (_("Unable to display \"%s\": %s"),
1893 d
->exp_string
, ex
.message
);
1901 if (d
->pspace
== current_program_space
)
1902 within_current_scope
= contained_in (get_selected_block (0), d
->block
);
1904 within_current_scope
= 0;
1907 within_current_scope
= 1;
1908 if (!within_current_scope
)
1911 scoped_restore save_display_number
1912 = make_scoped_restore (¤t_display_number
, d
->number
);
1914 annotate_display_begin ();
1915 printf_filtered ("%d", d
->number
);
1916 annotate_display_number_end ();
1917 printf_filtered (": ");
1921 annotate_display_format ();
1923 printf_filtered ("x/");
1924 if (d
->format
.count
!= 1)
1925 printf_filtered ("%d", d
->format
.count
);
1926 printf_filtered ("%c", d
->format
.format
);
1927 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1928 printf_filtered ("%c", d
->format
.size
);
1929 printf_filtered (" ");
1931 annotate_display_expression ();
1933 puts_filtered (d
->exp_string
);
1934 annotate_display_expression_end ();
1936 if (d
->format
.count
!= 1 || d
->format
.format
== 'i')
1937 printf_filtered ("\n");
1939 printf_filtered (" ");
1941 annotate_display_value ();
1948 val
= evaluate_expression (d
->exp
.get ());
1949 addr
= value_as_address (val
);
1950 if (d
->format
.format
== 'i')
1951 addr
= gdbarch_addr_bits_remove (d
->exp
->gdbarch
, addr
);
1952 do_examine (d
->format
, d
->exp
->gdbarch
, addr
);
1954 CATCH (ex
, RETURN_MASK_ERROR
)
1956 fprintf_filtered (gdb_stdout
, _("<error: %s>\n"), ex
.message
);
1962 struct value_print_options opts
;
1964 annotate_display_format ();
1966 if (d
->format
.format
)
1967 printf_filtered ("/%c ", d
->format
.format
);
1969 annotate_display_expression ();
1971 puts_filtered (d
->exp_string
);
1972 annotate_display_expression_end ();
1974 printf_filtered (" = ");
1976 annotate_display_expression ();
1978 get_formatted_print_options (&opts
, d
->format
.format
);
1979 opts
.raw
= d
->format
.raw
;
1985 val
= evaluate_expression (d
->exp
.get ());
1986 print_formatted (val
, d
->format
.size
, &opts
, gdb_stdout
);
1988 CATCH (ex
, RETURN_MASK_ERROR
)
1990 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
1994 printf_filtered ("\n");
1997 annotate_display_end ();
1999 gdb_flush (gdb_stdout
);
2002 /* Display all of the values on the auto-display chain which can be
2003 evaluated in the current scope. */
2010 for (d
= display_chain
; d
; d
= d
->next
)
2014 /* Delete the auto-display which we were in the process of displaying.
2015 This is done when there is an error or a signal. */
2018 disable_display (int num
)
2022 for (d
= display_chain
; d
; d
= d
->next
)
2023 if (d
->number
== num
)
2028 printf_unfiltered (_("No display number %d.\n"), num
);
2032 disable_current_display (void)
2034 if (current_display_number
>= 0)
2036 disable_display (current_display_number
);
2037 fprintf_unfiltered (gdb_stderr
,
2038 _("Disabling display %d to "
2039 "avoid infinite recursion.\n"),
2040 current_display_number
);
2042 current_display_number
= -1;
2046 info_display_command (char *ignore
, int from_tty
)
2051 printf_unfiltered (_("There are no auto-display expressions now.\n"));
2053 printf_filtered (_("Auto-display expressions now in effect:\n\
2054 Num Enb Expression\n"));
2056 for (d
= display_chain
; d
; d
= d
->next
)
2058 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
2060 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
2062 else if (d
->format
.format
)
2063 printf_filtered ("/%c ", d
->format
.format
);
2064 puts_filtered (d
->exp_string
);
2065 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
))
2066 printf_filtered (_(" (cannot be evaluated in the current context)"));
2067 printf_filtered ("\n");
2068 gdb_flush (gdb_stdout
);
2072 /* Callback fo map_display_numbers, that enables or disables the
2073 passed in display D. */
2076 do_enable_disable_display (struct display
*d
, void *data
)
2078 d
->enabled_p
= *(int *) data
;
2081 /* Implamentation of both the "disable display" and "enable display"
2082 commands. ENABLE decides what to do. */
2085 enable_disable_display_command (const char *args
, int from_tty
, int enable
)
2092 d
->enabled_p
= enable
;
2096 map_display_numbers (args
, do_enable_disable_display
, &enable
);
2099 /* The "enable display" command. */
2102 enable_display_command (const char *args
, int from_tty
)
2104 enable_disable_display_command (args
, from_tty
, 1);
2107 /* The "disable display" command. */
2110 disable_display_command (const char *args
, int from_tty
)
2112 enable_disable_display_command (args
, from_tty
, 0);
2115 /* display_chain items point to blocks and expressions. Some expressions in
2116 turn may point to symbols.
2117 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
2118 obstack_free'd when a shared library is unloaded.
2119 Clear pointers that are about to become dangling.
2120 Both .exp and .block fields will be restored next time we need to display
2121 an item by re-parsing .exp_string field in the new execution context. */
2124 clear_dangling_display_expressions (struct objfile
*objfile
)
2127 struct program_space
*pspace
;
2129 /* With no symbol file we cannot have a block or expression from it. */
2130 if (objfile
== NULL
)
2132 pspace
= objfile
->pspace
;
2133 if (objfile
->separate_debug_objfile_backlink
)
2135 objfile
= objfile
->separate_debug_objfile_backlink
;
2136 gdb_assert (objfile
->pspace
== pspace
);
2139 for (d
= display_chain
; d
!= NULL
; d
= d
->next
)
2141 if (d
->pspace
!= pspace
)
2144 if (lookup_objfile_from_block (d
->block
) == objfile
2145 || (d
->exp
!= NULL
&& exp_uses_objfile (d
->exp
.get (), objfile
)))
2154 /* Print the value in stack frame FRAME of a variable specified by a
2155 struct symbol. NAME is the name to print; if NULL then VAR's print
2156 name will be used. STREAM is the ui_file on which to print the
2157 value. INDENT specifies the number of indent levels to print
2158 before printing the variable name.
2160 This function invalidates FRAME. */
2163 print_variable_and_value (const char *name
, struct symbol
*var
,
2164 struct frame_info
*frame
,
2165 struct ui_file
*stream
, int indent
)
2169 name
= SYMBOL_PRINT_NAME (var
);
2171 fprintf_filtered (stream
, "%s%s = ", n_spaces (2 * indent
), name
);
2175 struct value_print_options opts
;
2177 /* READ_VAR_VALUE needs a block in order to deal with non-local
2178 references (i.e. to handle nested functions). In this context, we
2179 print variables that are local to this frame, so we can avoid passing
2181 val
= read_var_value (var
, NULL
, frame
);
2182 get_user_print_options (&opts
);
2184 common_val_print (val
, stream
, indent
, &opts
, current_language
);
2186 /* common_val_print invalidates FRAME when a pretty printer calls inferior
2190 CATCH (except
, RETURN_MASK_ERROR
)
2192 fprintf_filtered(stream
, "<error reading variable %s (%s)>", name
,
2197 fprintf_filtered (stream
, "\n");
2200 /* Subroutine of ui_printf to simplify it.
2201 Print VALUE to STREAM using FORMAT.
2202 VALUE is a C-style string on the target. */
2205 printf_c_string (struct ui_file
*stream
, const char *format
,
2206 struct value
*value
)
2212 tem
= value_as_address (value
);
2214 /* This is a %s argument. Find the length of the string. */
2220 read_memory (tem
+ j
, &c
, 1);
2225 /* Copy the string contents into a string inside GDB. */
2226 str
= (gdb_byte
*) alloca (j
+ 1);
2228 read_memory (tem
, str
, j
);
2231 fprintf_filtered (stream
, format
, (char *) str
);
2234 /* Subroutine of ui_printf to simplify it.
2235 Print VALUE to STREAM using FORMAT.
2236 VALUE is a wide C-style string on the target. */
2239 printf_wide_c_string (struct ui_file
*stream
, const char *format
,
2240 struct value
*value
)
2245 struct gdbarch
*gdbarch
= get_type_arch (value_type (value
));
2246 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2247 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2248 "wchar_t", NULL
, 0);
2249 int wcwidth
= TYPE_LENGTH (wctype
);
2250 gdb_byte
*buf
= (gdb_byte
*) alloca (wcwidth
);
2252 tem
= value_as_address (value
);
2254 /* This is a %s argument. Find the length of the string. */
2255 for (j
= 0;; j
+= wcwidth
)
2258 read_memory (tem
+ j
, buf
, wcwidth
);
2259 if (extract_unsigned_integer (buf
, wcwidth
, byte_order
) == 0)
2263 /* Copy the string contents into a string inside GDB. */
2264 str
= (gdb_byte
*) alloca (j
+ wcwidth
);
2266 read_memory (tem
, str
, j
);
2267 memset (&str
[j
], 0, wcwidth
);
2269 auto_obstack output
;
2271 convert_between_encodings (target_wide_charset (gdbarch
),
2274 &output
, translit_char
);
2275 obstack_grow_str0 (&output
, "");
2277 fprintf_filtered (stream
, format
, obstack_base (&output
));
2280 /* Subroutine of ui_printf to simplify it.
2281 Print VALUE, a decimal floating point value, to STREAM using FORMAT. */
2284 printf_decfloat (struct ui_file
*stream
, const char *format
,
2285 struct value
*value
)
2287 const gdb_byte
*param_ptr
= value_contents (value
);
2289 #if defined (PRINTF_HAS_DECFLOAT)
2290 /* If we have native support for Decimal floating
2291 printing, handle it here. */
2292 fprintf_filtered (stream
, format
, param_ptr
);
2294 /* As a workaround until vasprintf has native support for DFP
2295 we convert the DFP values to string and print them using
2296 the %s format specifier. */
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 /* DFP output data. */
2305 struct value
*dfp_value
= NULL
;
2309 struct type
*dfp_type
= NULL
;
2311 /* Points to the end of the string so that we can go back
2312 and check for DFP length modifiers. */
2313 p
= format
+ strlen (format
);
2315 /* Look for the float/double format specifier. */
2316 while (*p
!= 'f' && *p
!= 'e' && *p
!= 'E'
2317 && *p
!= 'g' && *p
!= 'G')
2320 /* Search for the '%' char and extract the size and type of
2321 the output decimal value based on its modifiers
2322 (%Hf, %Df, %DDf). */
2328 dfp_type
= builtin_type (gdbarch
)->builtin_decfloat
;
2330 else if (*p
== 'D' && *(p
- 1) == 'D')
2333 dfp_type
= builtin_type (gdbarch
)->builtin_declong
;
2339 dfp_type
= builtin_type (gdbarch
)->builtin_decdouble
;
2343 /* Conversion between different DFP types. */
2344 if (TYPE_CODE (param_type
) == TYPE_CODE_DECFLOAT
)
2345 decimal_convert (param_ptr
, TYPE_LENGTH (param_type
),
2346 byte_order
, dec
, dfp_len
, byte_order
);
2348 /* If this is a non-trivial conversion, just output 0.
2349 A correct converted value can be displayed by explicitly
2350 casting to a DFP type. */
2351 decimal_from_string (dec
, dfp_len
, byte_order
, "0");
2353 dfp_value
= value_from_decfloat (dfp_type
, dec
);
2355 dfp_ptr
= (gdb_byte
*) value_contents (dfp_value
);
2357 /* Convert the value to a string and print it. */
2358 std::string str
= decimal_to_string (dfp_ptr
, dfp_len
, byte_order
);
2359 fputs_filtered (str
.c_str (), stream
);
2363 /* Subroutine of ui_printf to simplify it.
2364 Print VALUE, a target pointer, to STREAM using FORMAT. */
2367 printf_pointer (struct ui_file
*stream
, const char *format
,
2368 struct value
*value
)
2370 /* We avoid the host's %p because pointers are too
2371 likely to be the wrong size. The only interesting
2372 modifier for %p is a width; extract that, and then
2373 handle %p as glibc would: %#x or a literal "(nil)". */
2377 #ifdef PRINTF_HAS_LONG_LONG
2378 long long val
= value_as_long (value
);
2380 long val
= value_as_long (value
);
2383 fmt
= (char *) alloca (strlen (format
) + 5);
2385 /* Copy up to the leading %. */
2390 int is_percent
= (*p
== '%');
2405 /* Copy any width. */
2406 while (*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 struct format_piece
*fpieces
;
2434 const char *s
= arg
;
2435 struct value
**val_args
;
2436 int allocated_args
= 20;
2437 struct cleanup
*old_cleanups
;
2439 val_args
= XNEWVEC (struct value
*, allocated_args
);
2440 old_cleanups
= make_cleanup (free_current_contents
, &val_args
);
2443 error_no_arg (_("format-control string and values to print"));
2445 s
= skip_spaces (s
);
2447 /* A format string should follow, enveloped in double quotes. */
2449 error (_("Bad format string, missing '\"'."));
2451 fpieces
= parse_format_string (&s
);
2453 make_cleanup (free_format_pieces_cleanup
, &fpieces
);
2456 error (_("Bad format string, non-terminated '\"'."));
2458 s
= skip_spaces (s
);
2460 if (*s
!= ',' && *s
!= 0)
2461 error (_("Invalid argument syntax"));
2465 s
= skip_spaces (s
);
2471 char *current_substring
;
2474 for (fr
= 0; fpieces
[fr
].string
!= NULL
; fr
++)
2475 if (fpieces
[fr
].argclass
!= literal_piece
)
2478 /* Now, parse all arguments and evaluate them.
2479 Store the VALUEs in VAL_ARGS. */
2485 if (nargs
== allocated_args
)
2486 val_args
= (struct value
**) xrealloc ((char *) val_args
,
2487 (allocated_args
*= 2)
2488 * sizeof (struct value
*));
2490 val_args
[nargs
] = parse_to_comma_and_eval (&s1
);
2498 if (nargs
!= nargs_wanted
)
2499 error (_("Wrong number of arguments for specified format-string"));
2501 /* Now actually print them. */
2503 for (fr
= 0; fpieces
[fr
].string
!= NULL
; fr
++)
2505 current_substring
= fpieces
[fr
].string
;
2506 switch (fpieces
[fr
].argclass
)
2509 printf_c_string (stream
, current_substring
, val_args
[i
]);
2511 case wide_string_arg
:
2512 printf_wide_c_string (stream
, current_substring
, val_args
[i
]);
2516 struct gdbarch
*gdbarch
2517 = get_type_arch (value_type (val_args
[i
]));
2518 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2519 "wchar_t", NULL
, 0);
2520 struct type
*valtype
;
2521 const gdb_byte
*bytes
;
2523 valtype
= value_type (val_args
[i
]);
2524 if (TYPE_LENGTH (valtype
) != TYPE_LENGTH (wctype
)
2525 || TYPE_CODE (valtype
) != TYPE_CODE_INT
)
2526 error (_("expected wchar_t argument for %%lc"));
2528 bytes
= value_contents (val_args
[i
]);
2530 auto_obstack output
;
2532 convert_between_encodings (target_wide_charset (gdbarch
),
2534 bytes
, TYPE_LENGTH (valtype
),
2535 TYPE_LENGTH (valtype
),
2536 &output
, translit_char
);
2537 obstack_grow_str0 (&output
, "");
2539 fprintf_filtered (stream
, current_substring
,
2540 obstack_base (&output
));
2545 struct type
*type
= value_type (val_args
[i
]);
2549 /* If format string wants a float, unchecked-convert the value
2550 to floating point of the same size. */
2551 type
= float_type_from_length (type
);
2552 val
= unpack_double (type
, value_contents (val_args
[i
]), &inv
);
2554 error (_("Invalid floating value found in program."));
2556 fprintf_filtered (stream
, current_substring
, (double) val
);
2559 case long_double_arg
:
2560 #ifdef HAVE_LONG_DOUBLE
2562 struct type
*type
= value_type (val_args
[i
]);
2566 /* If format string wants a float, unchecked-convert the value
2567 to floating point of the same size. */
2568 type
= float_type_from_length (type
);
2569 val
= unpack_double (type
, value_contents (val_args
[i
]), &inv
);
2571 error (_("Invalid floating value found in program."));
2573 fprintf_filtered (stream
, current_substring
,
2578 error (_("long double not supported in printf"));
2581 #ifdef PRINTF_HAS_LONG_LONG
2583 long long val
= value_as_long (val_args
[i
]);
2585 fprintf_filtered (stream
, current_substring
, val
);
2589 error (_("long long not supported in printf"));
2593 int val
= value_as_long (val_args
[i
]);
2595 fprintf_filtered (stream
, current_substring
, val
);
2600 long val
= value_as_long (val_args
[i
]);
2602 fprintf_filtered (stream
, current_substring
, val
);
2605 /* Handles decimal floating values. */
2607 printf_decfloat (stream
, current_substring
, val_args
[i
]);
2610 printf_pointer (stream
, current_substring
, val_args
[i
]);
2613 /* Print a portion of the format string that has no
2614 directives. Note that this will not include any
2615 ordinary %-specs, but it might include "%%". That is
2616 why we use printf_filtered and not puts_filtered here.
2617 Also, we pass a dummy argument because some platforms
2618 have modified GCC to include -Wformat-security by
2619 default, which will warn here if there is no
2621 fprintf_filtered (stream
, current_substring
, 0);
2624 internal_error (__FILE__
, __LINE__
,
2625 _("failed internal consistency check"));
2627 /* Maybe advance to the next argument. */
2628 if (fpieces
[fr
].argclass
!= literal_piece
)
2632 do_cleanups (old_cleanups
);
2635 /* Implement the "printf" command. */
2638 printf_command (char *arg
, int from_tty
)
2640 ui_printf (arg
, gdb_stdout
);
2641 gdb_flush (gdb_stdout
);
2644 /* Implement the "eval" command. */
2647 eval_command (char *arg
, int from_tty
)
2651 ui_printf (arg
, &stb
);
2653 std::string expanded
= insert_user_defined_cmd_args (stb
.c_str ());
2655 execute_command (&expanded
[0], from_tty
);
2659 _initialize_printcmd (void)
2661 struct cmd_list_element
*c
;
2663 current_display_number
= -1;
2665 observer_attach_free_objfile (clear_dangling_display_expressions
);
2667 add_info ("address", info_address_command
,
2668 _("Describe where symbol SYM is stored."));
2670 add_info ("symbol", info_symbol_command
, _("\
2671 Describe what symbol is at location ADDR.\n\
2672 Only for symbols with fixed locations (global or static scope)."));
2674 add_com ("x", class_vars
, x_command
, _("\
2675 Examine memory: x/FMT ADDRESS.\n\
2676 ADDRESS is an expression for the memory address to examine.\n\
2677 FMT is a repeat count followed by a format letter and a size letter.\n\
2678 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2679 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2680 and z(hex, zero padded on the left).\n\
2681 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2682 The specified number of objects of the specified size are printed\n\
2683 according to the format. If a negative number is specified, memory is\n\
2684 examined backward from the address.\n\n\
2685 Defaults for format and size letters are those previously used.\n\
2686 Default count is 1. Default address is following last thing printed\n\
2687 with this command or \"print\"."));
2690 add_com ("whereis", class_vars
, whereis_command
,
2691 _("Print line number and file of definition of variable."));
2694 add_info ("display", info_display_command
, _("\
2695 Expressions to display when program stops, with code numbers."));
2697 add_cmd ("undisplay", class_vars
, undisplay_command
, _("\
2698 Cancel some expressions to be displayed when program stops.\n\
2699 Arguments are the code numbers of the expressions to stop displaying.\n\
2700 No argument means cancel all automatic-display expressions.\n\
2701 \"delete display\" has the same effect as this command.\n\
2702 Do \"info display\" to see current list of code numbers."),
2705 add_com ("display", class_vars
, display_command
, _("\
2706 Print value of expression EXP each time the program stops.\n\
2707 /FMT may be used before EXP as in the \"print\" command.\n\
2708 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2709 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2710 and examining is done as in the \"x\" command.\n\n\
2711 With no argument, display all currently requested auto-display expressions.\n\
2712 Use \"undisplay\" to cancel display requests previously made."));
2714 add_cmd ("display", class_vars
, enable_display_command
, _("\
2715 Enable some expressions to be displayed when program stops.\n\
2716 Arguments are the code numbers of the expressions to resume displaying.\n\
2717 No argument means enable all automatic-display expressions.\n\
2718 Do \"info display\" to see current list of code numbers."), &enablelist
);
2720 add_cmd ("display", class_vars
, disable_display_command
, _("\
2721 Disable some expressions to be displayed when program stops.\n\
2722 Arguments are the code numbers of the expressions to stop displaying.\n\
2723 No argument means disable all automatic-display expressions.\n\
2724 Do \"info display\" to see current list of code numbers."), &disablelist
);
2726 add_cmd ("display", class_vars
, undisplay_command
, _("\
2727 Cancel some expressions to be displayed when program stops.\n\
2728 Arguments are the code numbers of the expressions to stop displaying.\n\
2729 No argument means cancel all automatic-display expressions.\n\
2730 Do \"info display\" to see current list of code numbers."), &deletelist
);
2732 add_com ("printf", class_vars
, printf_command
, _("\
2733 printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2734 This is useful for formatted output in user-defined commands."));
2736 add_com ("output", class_vars
, output_command
, _("\
2737 Like \"print\" but don't put in value history and don't print newline.\n\
2738 This is useful in user-defined commands."));
2740 add_prefix_cmd ("set", class_vars
, set_command
, _("\
2741 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2742 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2743 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2744 with $), a register (a few standard names starting with $), or an actual\n\
2745 variable in the program being debugged. EXP is any valid expression.\n\
2746 Use \"set variable\" for variables with names identical to set subcommands.\n\
2748 With a subcommand, this command modifies parts of the gdb environment.\n\
2749 You can see these environment settings with the \"show\" command."),
2750 &setlist
, "set ", 1, &cmdlist
);
2752 add_com ("assign", class_vars
, set_command
, _("\
2753 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2754 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2755 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2756 with $), a register (a few standard names starting with $), or an actual\n\
2757 variable in the program being debugged. EXP is any valid expression.\n\
2758 Use \"set variable\" for variables with names identical to set subcommands.\n\
2759 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2760 You can see these environment settings with the \"show\" command."));
2762 /* "call" is the same as "set", but handy for dbx users to call fns. */
2763 c
= add_com ("call", class_vars
, call_command
, _("\
2764 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, using assignment\n\
2772 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2773 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2774 with $), a register (a few standard names starting with $), or an actual\n\
2775 variable in the program being debugged. EXP is any valid expression.\n\
2776 This may usually be abbreviated to simply \"set\"."),
2779 c
= add_com ("print", class_vars
, print_command
, _("\
2780 Print value of expression EXP.\n\
2781 Variables accessible are those of the lexical environment of the selected\n\
2782 stack frame, plus all those whose scope is global or an entire file.\n\
2784 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2785 $$NUM refers to NUM'th value back from the last one.\n\
2786 Names starting with $ refer to registers (with the values they would have\n\
2787 if the program were to return to the stack frame now selected, restoring\n\
2788 all registers saved by frames farther in) or else to debugger\n\
2789 \"convenience\" variables (any such name not a known register).\n\
2790 Use assignment expressions to give values to convenience variables.\n\
2792 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2793 @ is a binary operator for treating consecutive data objects\n\
2794 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2795 element is FOO, whose second element is stored in the space following\n\
2796 where FOO is stored, etc. FOO must be an expression whose value\n\
2797 resides in memory.\n\
2799 EXP may be preceded with /FMT, where FMT is a format letter\n\
2800 but no count or size letter (see \"x\" command)."));
2801 set_cmd_completer (c
, expression_completer
);
2802 add_com_alias ("p", "print", class_vars
, 1);
2803 add_com_alias ("inspect", "print", class_vars
, 1);
2805 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class
,
2806 &max_symbolic_offset
, _("\
2807 Set the largest offset that will be printed in <symbol+1234> form."), _("\
2808 Show the largest offset that will be printed in <symbol+1234> form."), _("\
2809 Tell GDB to only display the symbolic form of an address if the\n\
2810 offset between the closest earlier symbol and the address is less than\n\
2811 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
2812 to always print the symbolic form of an address if any symbol precedes\n\
2813 it. Zero is equivalent to \"unlimited\"."),
2815 show_max_symbolic_offset
,
2816 &setprintlist
, &showprintlist
);
2817 add_setshow_boolean_cmd ("symbol-filename", no_class
,
2818 &print_symbol_filename
, _("\
2819 Set printing of source filename and line number with <symbol>."), _("\
2820 Show printing of source filename and line number with <symbol>."), NULL
,
2822 show_print_symbol_filename
,
2823 &setprintlist
, &showprintlist
);
2825 add_com ("eval", no_class
, eval_command
, _("\
2826 Convert \"printf format string\", arg1, arg2, arg3, ..., argn to\n\
2827 a command line, and call it."));