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"
53 #include "tui/tui.h" /* For tui_active et al. */
56 /* Last specified output format. */
58 static char last_format
= 0;
60 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
62 static char last_size
= 'w';
64 /* Default address to examine next, and associated architecture. */
66 static struct gdbarch
*next_gdbarch
;
67 static CORE_ADDR next_address
;
69 /* Number of delay instructions following current disassembled insn. */
71 static int branch_delay_insns
;
73 /* Last address examined. */
75 static CORE_ADDR last_examine_address
;
77 /* Contents of last address examined.
78 This is not valid past the end of the `x' command! */
80 static struct value
*last_examine_value
;
82 /* Largest offset between a symbolic value and an address, that will be
83 printed as `0x1234 <symbol+offset>'. */
85 static unsigned int max_symbolic_offset
= UINT_MAX
;
87 show_max_symbolic_offset (struct ui_file
*file
, int from_tty
,
88 struct cmd_list_element
*c
, const char *value
)
90 fprintf_filtered (file
,
91 _("The largest offset that will be "
92 "printed in <symbol+1234> form is %s.\n"),
96 /* Append the source filename and linenumber of the symbol when
97 printing a symbolic value as `<symbol at filename:linenum>' if set. */
98 static int print_symbol_filename
= 0;
100 show_print_symbol_filename (struct ui_file
*file
, int from_tty
,
101 struct cmd_list_element
*c
, const char *value
)
103 fprintf_filtered (file
, _("Printing of source filename and "
104 "line number with <symbol> is %s.\n"),
108 /* Number of auto-display expression currently being displayed.
109 So that we can disable it if we get a signal within it.
110 -1 when not doing one. */
112 static int current_display_number
;
116 /* Chain link to next auto-display item. */
117 struct display
*next
;
119 /* The expression as the user typed it. */
122 /* Expression to be evaluated and displayed. */
125 /* Item number of this auto-display item. */
128 /* Display format specified. */
129 struct format_data format
;
131 /* Program space associated with `block'. */
132 struct program_space
*pspace
;
134 /* Innermost block required by this expression when evaluated. */
135 const struct block
*block
;
137 /* Status of this display (enabled or disabled). */
141 /* Chain of expressions whose values should be displayed
142 automatically each time the program stops. */
144 static struct display
*display_chain
;
146 static int display_number
;
148 /* Walk the following statement or block through all displays.
149 ALL_DISPLAYS_SAFE does so even if the statement deletes the current
152 #define ALL_DISPLAYS(B) \
153 for (B = display_chain; B; B = B->next)
155 #define ALL_DISPLAYS_SAFE(B,TMP) \
156 for (B = display_chain; \
157 B ? (TMP = B->next, 1): 0; \
160 /* Prototypes for exported functions. */
162 void _initialize_printcmd (void);
164 /* Prototypes for local functions. */
166 static void do_one_display (struct display
*);
169 /* Decode a format specification. *STRING_PTR should point to it.
170 OFORMAT and OSIZE are used as defaults for the format and size
171 if none are given in the format specification.
172 If OSIZE is zero, then the size field of the returned value
173 should be set only if a size is explicitly specified by the
175 The structure returned describes all the data
176 found in the specification. In addition, *STRING_PTR is advanced
177 past the specification and past all whitespace following it. */
179 static struct format_data
180 decode_format (const char **string_ptr
, int oformat
, int osize
)
182 struct format_data val
;
183 const char *p
= *string_ptr
;
195 if (*p
>= '0' && *p
<= '9')
196 val
.count
*= atoi (p
);
197 while (*p
>= '0' && *p
<= '9')
200 /* Now process size or format letters that follow. */
204 if (*p
== 'b' || *p
== 'h' || *p
== 'w' || *p
== 'g')
211 else if (*p
>= 'a' && *p
<= 'z')
217 while (*p
== ' ' || *p
== '\t')
221 /* Set defaults for format and size if not specified. */
222 if (val
.format
== '?')
226 /* Neither has been specified. */
227 val
.format
= oformat
;
231 /* If a size is specified, any format makes a reasonable
232 default except 'i'. */
233 val
.format
= oformat
== 'i' ? 'x' : oformat
;
235 else if (val
.size
== '?')
239 /* Pick the appropriate size for an address. This is deferred
240 until do_examine when we know the actual architecture to use.
241 A special size value of 'a' is used to indicate this case. */
242 val
.size
= osize
? 'a' : osize
;
245 /* Floating point has to be word or giantword. */
246 if (osize
== 'w' || osize
== 'g')
249 /* Default it to giantword if the last used size is not
251 val
.size
= osize
? 'g' : osize
;
254 /* Characters default to one byte. */
255 val
.size
= osize
? 'b' : osize
;
258 /* Display strings with byte size chars unless explicitly
264 /* The default is the size most recently specified. */
271 /* Print value VAL on stream according to OPTIONS.
272 Do not end with a newline.
273 SIZE is the letter for the size of datum being printed.
274 This is used to pad hex numbers so they line up. SIZE is 0
275 for print / output and set for examine. */
278 print_formatted (struct value
*val
, int size
,
279 const struct value_print_options
*options
,
280 struct ui_file
*stream
)
282 struct type
*type
= check_typedef (value_type (val
));
283 int len
= TYPE_LENGTH (type
);
285 if (VALUE_LVAL (val
) == lval_memory
)
286 next_address
= value_address (val
) + len
;
290 switch (options
->format
)
294 struct type
*elttype
= value_type (val
);
296 next_address
= (value_address (val
)
297 + val_print_string (elttype
, NULL
,
298 value_address (val
), -1,
299 stream
, options
) * len
);
304 /* We often wrap here if there are long symbolic names. */
306 next_address
= (value_address (val
)
307 + gdb_print_insn (get_type_arch (type
),
308 value_address (val
), stream
,
309 &branch_delay_insns
));
314 if (options
->format
== 0 || options
->format
== 's'
315 || TYPE_CODE (type
) == TYPE_CODE_REF
316 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
317 || TYPE_CODE (type
) == TYPE_CODE_STRING
318 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
319 || TYPE_CODE (type
) == TYPE_CODE_UNION
320 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
321 value_print (val
, stream
, options
);
323 /* User specified format, so don't look to the type to tell us
325 val_print_scalar_formatted (type
,
326 value_embedded_offset (val
),
328 options
, size
, stream
);
331 /* Return builtin floating point type of same length as TYPE.
332 If no such type is found, return TYPE itself. */
334 float_type_from_length (struct type
*type
)
336 struct gdbarch
*gdbarch
= get_type_arch (type
);
337 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
339 if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_float
))
340 type
= builtin
->builtin_float
;
341 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_double
))
342 type
= builtin
->builtin_double
;
343 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (builtin
->builtin_long_double
))
344 type
= builtin
->builtin_long_double
;
349 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
350 according to OPTIONS and SIZE on STREAM. Formats s and i are not
351 supported at this level. */
354 print_scalar_formatted (const gdb_byte
*valaddr
, struct type
*type
,
355 const struct value_print_options
*options
,
356 int size
, struct ui_file
*stream
)
358 struct gdbarch
*gdbarch
= get_type_arch (type
);
359 LONGEST val_long
= 0;
360 unsigned int len
= TYPE_LENGTH (type
);
361 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
363 /* String printing should go through val_print_scalar_formatted. */
364 gdb_assert (options
->format
!= 's');
366 if (len
> sizeof(LONGEST
)
367 && (TYPE_CODE (type
) == TYPE_CODE_INT
368 || TYPE_CODE (type
) == TYPE_CODE_ENUM
))
370 switch (options
->format
)
373 print_octal_chars (stream
, valaddr
, len
, byte_order
);
377 print_decimal_chars (stream
, valaddr
, len
, byte_order
);
380 print_binary_chars (stream
, valaddr
, len
, byte_order
);
383 print_hex_chars (stream
, valaddr
, len
, byte_order
);
386 print_char_chars (stream
, type
, valaddr
, len
, byte_order
);
393 if (options
->format
!= 'f')
394 val_long
= unpack_long (type
, valaddr
);
396 /* If the value is a pointer, and pointers and addresses are not the
397 same, then at this point, the value's length (in target bytes) is
398 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
399 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
400 len
= gdbarch_addr_bit (gdbarch
) / TARGET_CHAR_BIT
;
402 /* If we are printing it as unsigned, truncate it in case it is actually
403 a negative signed value (e.g. "print/u (short)-1" should print 65535
404 (if shorts are 16 bits) instead of 4294967295). */
405 if (options
->format
!= 'd' || TYPE_UNSIGNED (type
))
407 if (len
< sizeof (LONGEST
))
408 val_long
&= ((LONGEST
) 1 << HOST_CHAR_BIT
* len
) - 1;
411 switch (options
->format
)
416 /* No size specified, like in print. Print varying # of digits. */
417 print_longest (stream
, 'x', 1, val_long
);
426 print_longest (stream
, size
, 1, val_long
);
429 error (_("Undefined output size \"%c\"."), size
);
434 print_longest (stream
, 'd', 1, val_long
);
438 print_longest (stream
, 'u', 0, val_long
);
443 print_longest (stream
, 'o', 1, val_long
);
445 fprintf_filtered (stream
, "0");
450 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
452 print_address (gdbarch
, addr
, stream
);
458 struct value_print_options opts
= *options
;
461 if (TYPE_UNSIGNED (type
))
462 type
= builtin_type (gdbarch
)->builtin_true_unsigned_char
;
464 type
= builtin_type (gdbarch
)->builtin_true_char
;
466 value_print (value_from_longest (type
, val_long
), stream
, &opts
);
471 type
= float_type_from_length (type
);
472 print_floating (valaddr
, type
, stream
);
476 internal_error (__FILE__
, __LINE__
,
477 _("failed internal consistency check"));
480 /* Binary; 't' stands for "two". */
482 char bits
[8 * (sizeof val_long
) + 1];
483 char buf
[8 * (sizeof val_long
) + 32];
488 width
= 8 * (sizeof val_long
);
505 error (_("Undefined output size \"%c\"."), size
);
511 bits
[width
] = (val_long
& 1) ? '1' : '0';
516 while (*cp
&& *cp
== '0')
521 strncpy (buf
, cp
, sizeof (bits
));
522 fputs_filtered (buf
, stream
);
527 print_hex_chars (stream
, valaddr
, len
, byte_order
);
531 error (_("Undefined output format \"%c\"."), options
->format
);
535 /* Specify default address for `x' command.
536 The `info lines' command uses this. */
539 set_next_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
541 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
543 next_gdbarch
= gdbarch
;
546 /* Make address available to the user as $_. */
547 set_internalvar (lookup_internalvar ("_"),
548 value_from_pointer (ptr_type
, addr
));
551 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
552 after LEADIN. Print nothing if no symbolic name is found nearby.
553 Optionally also print source file and line number, if available.
554 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
555 or to interpret it as a possible C++ name and convert it back to source
556 form. However note that DO_DEMANGLE can be overridden by the specific
557 settings of the demangle and asm_demangle variables. Returns
558 non-zero if anything was printed; zero otherwise. */
561 print_address_symbolic (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
562 struct ui_file
*stream
,
563 int do_demangle
, const char *leadin
)
566 char *filename
= NULL
;
571 /* Throw away both name and filename. */
572 struct cleanup
*cleanup_chain
= make_cleanup (free_current_contents
, &name
);
573 make_cleanup (free_current_contents
, &filename
);
575 if (build_address_symbolic (gdbarch
, addr
, do_demangle
, &name
, &offset
,
576 &filename
, &line
, &unmapped
))
578 do_cleanups (cleanup_chain
);
582 fputs_filtered (leadin
, stream
);
584 fputs_filtered ("<*", stream
);
586 fputs_filtered ("<", stream
);
587 fputs_filtered (name
, stream
);
589 fprintf_filtered (stream
, "+%u", (unsigned int) offset
);
591 /* Append source filename and line number if desired. Give specific
592 line # of this addr, if we have it; else line # of the nearest symbol. */
593 if (print_symbol_filename
&& filename
!= NULL
)
596 fprintf_filtered (stream
, " at %s:%d", filename
, line
);
598 fprintf_filtered (stream
, " in %s", filename
);
601 fputs_filtered ("*>", stream
);
603 fputs_filtered (">", stream
);
605 do_cleanups (cleanup_chain
);
609 /* Given an address ADDR return all the elements needed to print the
610 address in a symbolic form. NAME can be mangled or not depending
611 on DO_DEMANGLE (and also on the asm_demangle global variable,
612 manipulated via ''set print asm-demangle''). Return 0 in case of
613 success, when all the info in the OUT paramters is valid. Return 1
616 build_address_symbolic (struct gdbarch
*gdbarch
,
617 CORE_ADDR addr
, /* IN */
618 int do_demangle
, /* IN */
619 char **name
, /* OUT */
620 int *offset
, /* OUT */
621 char **filename
, /* OUT */
623 int *unmapped
) /* OUT */
625 struct bound_minimal_symbol msymbol
;
626 struct symbol
*symbol
;
627 CORE_ADDR name_location
= 0;
628 struct obj_section
*section
= NULL
;
629 const char *name_temp
= "";
631 /* Let's say it is mapped (not unmapped). */
634 /* Determine if the address is in an overlay, and whether it is
636 if (overlay_debugging
)
638 section
= find_pc_overlay (addr
);
639 if (pc_in_unmapped_range (addr
, section
))
642 addr
= overlay_mapped_address (addr
, section
);
646 /* First try to find the address in the symbol table, then
647 in the minsyms. Take the closest one. */
649 /* This is defective in the sense that it only finds text symbols. So
650 really this is kind of pointless--we should make sure that the
651 minimal symbols have everything we need (by changing that we could
652 save some memory, but for many debug format--ELF/DWARF or
653 anything/stabs--it would be inconvenient to eliminate those minimal
655 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
656 symbol
= find_pc_sect_function (addr
, section
);
660 /* If this is a function (i.e. a code address), strip out any
661 non-address bits. For instance, display a pointer to the
662 first instruction of a Thumb function as <function>; the
663 second instruction will be <function+2>, even though the
664 pointer is <function+3>. This matches the ISA behavior. */
665 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
667 name_location
= BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
));
668 if (do_demangle
|| asm_demangle
)
669 name_temp
= SYMBOL_PRINT_NAME (symbol
);
671 name_temp
= SYMBOL_LINKAGE_NAME (symbol
);
674 if (msymbol
.minsym
!= NULL
675 && MSYMBOL_HAS_SIZE (msymbol
.minsym
)
676 && MSYMBOL_SIZE (msymbol
.minsym
) == 0
677 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text
678 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_text_gnu_ifunc
679 && MSYMBOL_TYPE (msymbol
.minsym
) != mst_file_text
)
680 msymbol
.minsym
= NULL
;
682 if (msymbol
.minsym
!= NULL
)
684 if (BMSYMBOL_VALUE_ADDRESS (msymbol
) > name_location
|| symbol
== NULL
)
686 /* If this is a function (i.e. a code address), strip out any
687 non-address bits. For instance, display a pointer to the
688 first instruction of a Thumb function as <function>; the
689 second instruction will be <function+2>, even though the
690 pointer is <function+3>. This matches the ISA behavior. */
691 if (MSYMBOL_TYPE (msymbol
.minsym
) == mst_text
692 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_text_gnu_ifunc
693 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_file_text
694 || MSYMBOL_TYPE (msymbol
.minsym
) == mst_solib_trampoline
)
695 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
697 /* The msymbol is closer to the address than the symbol;
698 use the msymbol instead. */
700 name_location
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
701 if (do_demangle
|| asm_demangle
)
702 name_temp
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
704 name_temp
= MSYMBOL_LINKAGE_NAME (msymbol
.minsym
);
707 if (symbol
== NULL
&& msymbol
.minsym
== NULL
)
710 /* If the nearest symbol is too far away, don't print anything symbolic. */
712 /* For when CORE_ADDR is larger than unsigned int, we do math in
713 CORE_ADDR. But when we detect unsigned wraparound in the
714 CORE_ADDR math, we ignore this test and print the offset,
715 because addr+max_symbolic_offset has wrapped through the end
716 of the address space back to the beginning, giving bogus comparison. */
717 if (addr
> name_location
+ max_symbolic_offset
718 && name_location
+ max_symbolic_offset
> name_location
)
721 *offset
= addr
- name_location
;
723 *name
= xstrdup (name_temp
);
725 if (print_symbol_filename
)
727 struct symtab_and_line sal
;
729 sal
= find_pc_sect_line (addr
, section
, 0);
733 *filename
= xstrdup (symtab_to_filename_for_display (sal
.symtab
));
741 /* Print address ADDR symbolically on STREAM.
742 First print it as a number. Then perhaps print
743 <SYMBOL + OFFSET> after the number. */
746 print_address (struct gdbarch
*gdbarch
,
747 CORE_ADDR addr
, struct ui_file
*stream
)
749 fputs_filtered (paddress (gdbarch
, addr
), stream
);
750 print_address_symbolic (gdbarch
, addr
, stream
, asm_demangle
, " ");
753 /* Return a prefix for instruction address:
754 "=> " for current instruction, else " ". */
757 pc_prefix (CORE_ADDR addr
)
759 if (has_stack_frames ())
761 struct frame_info
*frame
;
764 frame
= get_selected_frame (NULL
);
765 if (get_frame_pc_if_available (frame
, &pc
) && pc
== addr
)
771 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
772 controls whether to print the symbolic name "raw" or demangled.
773 Return non-zero if anything was printed; zero otherwise. */
776 print_address_demangle (const struct value_print_options
*opts
,
777 struct gdbarch
*gdbarch
, CORE_ADDR addr
,
778 struct ui_file
*stream
, int do_demangle
)
780 if (opts
->addressprint
)
782 fputs_filtered (paddress (gdbarch
, addr
), stream
);
783 print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, " ");
787 return print_address_symbolic (gdbarch
, addr
, stream
, do_demangle
, "");
793 /* Find the address of the instruction that is INST_COUNT instructions before
794 the instruction at ADDR.
795 Since some architectures have variable-length instructions, we can't just
796 simply subtract INST_COUNT * INSN_LEN from ADDR. Instead, we use line
797 number information to locate the nearest known instruction boundary,
798 and disassemble forward from there. If we go out of the symbol range
799 during disassembling, we return the lowest address we've got so far and
800 set the number of instructions read to INST_READ. */
803 find_instruction_backward (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
804 int inst_count
, int *inst_read
)
806 /* The vector PCS is used to store instruction addresses within
808 CORE_ADDR loop_start
, loop_end
, p
;
809 std::vector
<CORE_ADDR
> pcs
;
810 struct symtab_and_line sal
;
813 loop_start
= loop_end
= addr
;
815 /* In each iteration of the outer loop, we get a pc range that ends before
816 LOOP_START, then we count and store every instruction address of the range
817 iterated in the loop.
818 If the number of instructions counted reaches INST_COUNT, return the
819 stored address that is located INST_COUNT instructions back from ADDR.
820 If INST_COUNT is not reached, we subtract the number of counted
821 instructions from INST_COUNT, and go to the next iteration. */
825 sal
= find_pc_sect_line (loop_start
, NULL
, 1);
828 /* We reach here when line info is not available. In this case,
829 we print a message and just exit the loop. The return value
830 is calculated after the loop. */
831 printf_filtered (_("No line number information available "
834 print_address (gdbarch
, loop_start
- 1, gdb_stdout
);
835 printf_filtered ("\n");
839 loop_end
= loop_start
;
842 /* This loop pushes instruction addresses in the range from
843 LOOP_START to LOOP_END. */
844 for (p
= loop_start
; p
< loop_end
;)
847 p
+= gdb_insn_length (gdbarch
, p
);
850 inst_count
-= pcs
.size ();
851 *inst_read
+= pcs
.size ();
853 while (inst_count
> 0);
855 /* After the loop, the vector PCS has instruction addresses of the last
856 source line we processed, and INST_COUNT has a negative value.
857 We return the address at the index of -INST_COUNT in the vector for
859 Let's assume the following instruction addresses and run 'x/-4i 0x400e'.
869 find_instruction_backward is called with INST_COUNT = 4 and expected to
870 return 0x4001. When we reach here, INST_COUNT is set to -1 because
871 it was subtracted by 2 (from Line Y) and 3 (from Line X). The value
872 4001 is located at the index 1 of the last iterated line (= Line X),
873 which is simply calculated by -INST_COUNT.
874 The case when the length of PCS is 0 means that we reached an area for
875 which line info is not available. In such case, we return LOOP_START,
876 which was the lowest instruction address that had line info. */
877 p
= pcs
.size () > 0 ? pcs
[-inst_count
] : loop_start
;
879 /* INST_READ includes all instruction addresses in a pc range. Need to
880 exclude the beginning part up to the address we're returning. That
881 is, exclude {0x4000} in the example above. */
883 *inst_read
+= inst_count
;
888 /* Backward read LEN bytes of target memory from address MEMADDR + LEN,
889 placing the results in GDB's memory from MYADDR + LEN. Returns
890 a count of the bytes actually read. */
893 read_memory_backward (struct gdbarch
*gdbarch
,
894 CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
897 int nread
; /* Number of bytes actually read. */
899 /* First try a complete read. */
900 errcode
= target_read_memory (memaddr
, myaddr
, len
);
908 /* Loop, reading one byte at a time until we get as much as we can. */
911 for (nread
= 0; nread
< len
; ++nread
)
913 errcode
= target_read_memory (--memaddr
, --myaddr
, 1);
916 /* The read was unsuccessful, so exit the loop. */
917 printf_filtered (_("Cannot access memory at address %s\n"),
918 paddress (gdbarch
, memaddr
));
926 /* Returns true if X (which is LEN bytes wide) is the number zero. */
929 integer_is_zero (const gdb_byte
*x
, int len
)
933 while (i
< len
&& x
[i
] == 0)
938 /* Find the start address of a string in which ADDR is included.
939 Basically we search for '\0' and return the next address,
940 but if OPTIONS->PRINT_MAX is smaller than the length of a string,
941 we stop searching and return the address to print characters as many as
942 PRINT_MAX from the string. */
945 find_string_backward (struct gdbarch
*gdbarch
,
946 CORE_ADDR addr
, int count
, int char_size
,
947 const struct value_print_options
*options
,
948 int *strings_counted
)
950 const int chunk_size
= 0x20;
951 gdb_byte
*buffer
= NULL
;
952 struct cleanup
*cleanup
= NULL
;
955 int chars_to_read
= chunk_size
;
956 int chars_counted
= 0;
957 int count_original
= count
;
958 CORE_ADDR string_start_addr
= addr
;
960 gdb_assert (char_size
== 1 || char_size
== 2 || char_size
== 4);
961 buffer
= (gdb_byte
*) xmalloc (chars_to_read
* char_size
);
962 cleanup
= make_cleanup (xfree
, buffer
);
963 while (count
> 0 && read_error
== 0)
967 addr
-= chars_to_read
* char_size
;
968 chars_read
= read_memory_backward (gdbarch
, addr
, buffer
,
969 chars_to_read
* char_size
);
970 chars_read
/= char_size
;
971 read_error
= (chars_read
== chars_to_read
) ? 0 : 1;
972 /* Searching for '\0' from the end of buffer in backward direction. */
973 for (i
= 0; i
< chars_read
&& count
> 0 ; ++i
, ++chars_counted
)
975 int offset
= (chars_to_read
- i
- 1) * char_size
;
977 if (integer_is_zero (buffer
+ offset
, char_size
)
978 || chars_counted
== options
->print_max
)
980 /* Found '\0' or reached print_max. As OFFSET is the offset to
981 '\0', we add CHAR_SIZE to return the start address of
984 string_start_addr
= addr
+ offset
+ char_size
;
990 /* Update STRINGS_COUNTED with the actual number of loaded strings. */
991 *strings_counted
= count_original
- count
;
995 /* In error case, STRING_START_ADDR is pointing to the string that
996 was last successfully loaded. Rewind the partially loaded string. */
997 string_start_addr
-= chars_counted
* char_size
;
1000 do_cleanups (cleanup
);
1001 return string_start_addr
;
1004 /* Examine data at address ADDR in format FMT.
1005 Fetch it from memory and print on gdb_stdout. */
1008 do_examine (struct format_data fmt
, struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1013 struct type
*val_type
= NULL
;
1016 struct value_print_options opts
;
1017 int need_to_update_next_address
= 0;
1018 CORE_ADDR addr_rewound
= 0;
1020 format
= fmt
.format
;
1023 next_gdbarch
= gdbarch
;
1024 next_address
= addr
;
1026 /* Instruction format implies fetch single bytes
1027 regardless of the specified size.
1028 The case of strings is handled in decode_format, only explicit
1029 size operator are not changed to 'b'. */
1035 /* Pick the appropriate size for an address. */
1036 if (gdbarch_ptr_bit (next_gdbarch
) == 64)
1038 else if (gdbarch_ptr_bit (next_gdbarch
) == 32)
1040 else if (gdbarch_ptr_bit (next_gdbarch
) == 16)
1043 /* Bad value for gdbarch_ptr_bit. */
1044 internal_error (__FILE__
, __LINE__
,
1045 _("failed internal consistency check"));
1049 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1050 else if (size
== 'h')
1051 val_type
= builtin_type (next_gdbarch
)->builtin_int16
;
1052 else if (size
== 'w')
1053 val_type
= builtin_type (next_gdbarch
)->builtin_int32
;
1054 else if (size
== 'g')
1055 val_type
= builtin_type (next_gdbarch
)->builtin_int64
;
1059 struct type
*char_type
= NULL
;
1061 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
1062 if type is not found. */
1064 char_type
= builtin_type (next_gdbarch
)->builtin_char16
;
1065 else if (size
== 'w')
1066 char_type
= builtin_type (next_gdbarch
)->builtin_char32
;
1068 val_type
= char_type
;
1071 if (size
!= '\0' && size
!= 'b')
1072 warning (_("Unable to display strings with "
1073 "size '%c', using 'b' instead."), size
);
1075 val_type
= builtin_type (next_gdbarch
)->builtin_int8
;
1084 if (format
== 's' || format
== 'i')
1087 get_formatted_print_options (&opts
, format
);
1091 /* This is the negative repeat count case.
1092 We rewind the address based on the given repeat count and format,
1093 then examine memory from there in forward direction. */
1098 next_address
= find_instruction_backward (gdbarch
, addr
, count
,
1101 else if (format
== 's')
1103 next_address
= find_string_backward (gdbarch
, addr
, count
,
1104 TYPE_LENGTH (val_type
),
1109 next_address
= addr
- count
* TYPE_LENGTH (val_type
);
1112 /* The following call to print_formatted updates next_address in every
1113 iteration. In backward case, we store the start address here
1114 and update next_address with it before exiting the function. */
1115 addr_rewound
= (format
== 's'
1116 ? next_address
- TYPE_LENGTH (val_type
)
1118 need_to_update_next_address
= 1;
1121 /* Print as many objects as specified in COUNT, at most maxelts per line,
1122 with the address of the next one at the start of each line. */
1128 fputs_filtered (pc_prefix (next_address
), gdb_stdout
);
1129 print_address (next_gdbarch
, next_address
, gdb_stdout
);
1130 printf_filtered (":");
1135 printf_filtered ("\t");
1136 /* Note that print_formatted sets next_address for the next
1138 last_examine_address
= next_address
;
1140 if (last_examine_value
)
1141 value_free (last_examine_value
);
1143 /* The value to be displayed is not fetched greedily.
1144 Instead, to avoid the possibility of a fetched value not
1145 being used, its retrieval is delayed until the print code
1146 uses it. When examining an instruction stream, the
1147 disassembler will perform its own memory fetch using just
1148 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
1149 the disassembler be modified so that LAST_EXAMINE_VALUE
1150 is left with the byte sequence from the last complete
1151 instruction fetched from memory? */
1152 last_examine_value
= value_at_lazy (val_type
, next_address
);
1154 if (last_examine_value
)
1155 release_value (last_examine_value
);
1157 print_formatted (last_examine_value
, size
, &opts
, gdb_stdout
);
1159 /* Display any branch delay slots following the final insn. */
1160 if (format
== 'i' && count
== 1)
1161 count
+= branch_delay_insns
;
1163 printf_filtered ("\n");
1164 gdb_flush (gdb_stdout
);
1167 if (need_to_update_next_address
)
1168 next_address
= addr_rewound
;
1172 validate_format (struct format_data fmt
, const char *cmdname
)
1175 error (_("Size letters are meaningless in \"%s\" command."), cmdname
);
1177 error (_("Item count other than 1 is meaningless in \"%s\" command."),
1179 if (fmt
.format
== 'i')
1180 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
1181 fmt
.format
, cmdname
);
1184 /* Parse print command format string into *FMTP and update *EXPP.
1185 CMDNAME should name the current command. */
1188 print_command_parse_format (const char **expp
, const char *cmdname
,
1189 struct format_data
*fmtp
)
1191 const char *exp
= *expp
;
1193 if (exp
&& *exp
== '/')
1196 *fmtp
= decode_format (&exp
, last_format
, 0);
1197 validate_format (*fmtp
, cmdname
);
1198 last_format
= fmtp
->format
;
1211 /* Print VAL to console according to *FMTP, including recording it to
1215 print_value (struct value
*val
, const struct format_data
*fmtp
)
1217 struct value_print_options opts
;
1218 int histindex
= record_latest_value (val
);
1220 annotate_value_history_begin (histindex
, value_type (val
));
1222 printf_filtered ("$%d = ", histindex
);
1224 annotate_value_history_value ();
1226 get_formatted_print_options (&opts
, fmtp
->format
);
1227 opts
.raw
= fmtp
->raw
;
1229 print_formatted (val
, fmtp
->size
, &opts
, gdb_stdout
);
1230 printf_filtered ("\n");
1232 annotate_value_history_end ();
1235 /* Evaluate string EXP as an expression in the current language and
1236 print the resulting value. EXP may contain a format specifier as the
1237 first argument ("/x myvar" for example, to print myvar in hex). */
1240 print_command_1 (const char *exp
, int voidprint
)
1243 struct format_data fmt
;
1245 print_command_parse_format (&exp
, "print", &fmt
);
1249 expression_up expr
= parse_expression (exp
);
1250 val
= evaluate_expression (expr
.get ());
1253 val
= access_value_history (0);
1255 if (voidprint
|| (val
&& value_type (val
) &&
1256 TYPE_CODE (value_type (val
)) != TYPE_CODE_VOID
))
1257 print_value (val
, &fmt
);
1261 print_command (char *exp
, int from_tty
)
1263 print_command_1 (exp
, 1);
1266 /* Same as print, except it doesn't print void results. */
1268 call_command (char *exp
, int from_tty
)
1270 print_command_1 (exp
, 0);
1273 /* Implementation of the "output" command. */
1276 output_command (char *exp
, int from_tty
)
1278 output_command_const (exp
, from_tty
);
1281 /* Like output_command, but takes a const string as argument. */
1284 output_command_const (const char *exp
, int from_tty
)
1288 struct format_data fmt
;
1289 struct value_print_options opts
;
1294 if (exp
&& *exp
== '/')
1297 fmt
= decode_format (&exp
, 0, 0);
1298 validate_format (fmt
, "output");
1299 format
= fmt
.format
;
1302 expression_up expr
= parse_expression (exp
);
1304 val
= evaluate_expression (expr
.get ());
1306 annotate_value_begin (value_type (val
));
1308 get_formatted_print_options (&opts
, format
);
1310 print_formatted (val
, fmt
.size
, &opts
, gdb_stdout
);
1312 annotate_value_end ();
1315 gdb_flush (gdb_stdout
);
1319 set_command (char *exp
, int from_tty
)
1321 expression_up expr
= parse_expression (exp
);
1323 if (expr
->nelts
>= 1)
1324 switch (expr
->elts
[0].opcode
)
1326 case UNOP_PREINCREMENT
:
1327 case UNOP_POSTINCREMENT
:
1328 case UNOP_PREDECREMENT
:
1329 case UNOP_POSTDECREMENT
:
1331 case BINOP_ASSIGN_MODIFY
:
1336 (_("Expression is not an assignment (and might have no effect)"));
1339 evaluate_expression (expr
.get ());
1343 sym_info (char *arg
, int from_tty
)
1345 struct minimal_symbol
*msymbol
;
1346 struct objfile
*objfile
;
1347 struct obj_section
*osect
;
1348 CORE_ADDR addr
, sect_addr
;
1350 unsigned int offset
;
1353 error_no_arg (_("address"));
1355 addr
= parse_and_eval_address (arg
);
1356 ALL_OBJSECTIONS (objfile
, osect
)
1358 /* Only process each object file once, even if there's a separate
1360 if (objfile
->separate_debug_objfile_backlink
)
1363 sect_addr
= overlay_mapped_address (addr
, osect
);
1365 if (obj_section_addr (osect
) <= sect_addr
1366 && sect_addr
< obj_section_endaddr (osect
)
1368 = lookup_minimal_symbol_by_pc_section (sect_addr
, osect
).minsym
))
1370 const char *obj_name
, *mapped
, *sec_name
, *msym_name
;
1372 struct cleanup
*old_chain
;
1375 offset
= sect_addr
- MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
);
1376 mapped
= section_is_mapped (osect
) ? _("mapped") : _("unmapped");
1377 sec_name
= osect
->the_bfd_section
->name
;
1378 msym_name
= MSYMBOL_PRINT_NAME (msymbol
);
1380 /* Don't print the offset if it is zero.
1381 We assume there's no need to handle i18n of "sym + offset". */
1383 loc_string
= xstrprintf ("%s + %u", msym_name
, offset
);
1385 loc_string
= xstrprintf ("%s", msym_name
);
1387 /* Use a cleanup to free loc_string in case the user quits
1388 a pagination request inside printf_filtered. */
1389 old_chain
= make_cleanup (xfree
, loc_string
);
1391 gdb_assert (osect
->objfile
&& objfile_name (osect
->objfile
));
1392 obj_name
= objfile_name (osect
->objfile
);
1394 if (MULTI_OBJFILE_P ())
1395 if (pc_in_unmapped_range (addr
, osect
))
1396 if (section_is_overlay (osect
))
1397 printf_filtered (_("%s in load address range of "
1398 "%s overlay section %s of %s\n"),
1399 loc_string
, mapped
, sec_name
, obj_name
);
1401 printf_filtered (_("%s in load address range of "
1402 "section %s of %s\n"),
1403 loc_string
, sec_name
, obj_name
);
1405 if (section_is_overlay (osect
))
1406 printf_filtered (_("%s in %s overlay section %s of %s\n"),
1407 loc_string
, mapped
, sec_name
, obj_name
);
1409 printf_filtered (_("%s in section %s of %s\n"),
1410 loc_string
, sec_name
, obj_name
);
1412 if (pc_in_unmapped_range (addr
, osect
))
1413 if (section_is_overlay (osect
))
1414 printf_filtered (_("%s in load address range of %s overlay "
1416 loc_string
, mapped
, sec_name
);
1418 printf_filtered (_("%s in load address range of section %s\n"),
1419 loc_string
, sec_name
);
1421 if (section_is_overlay (osect
))
1422 printf_filtered (_("%s in %s overlay section %s\n"),
1423 loc_string
, mapped
, sec_name
);
1425 printf_filtered (_("%s in section %s\n"),
1426 loc_string
, sec_name
);
1428 do_cleanups (old_chain
);
1432 printf_filtered (_("No symbol matches %s.\n"), arg
);
1436 address_info (char *exp
, int from_tty
)
1438 struct gdbarch
*gdbarch
;
1441 struct bound_minimal_symbol msymbol
;
1443 struct obj_section
*section
;
1444 CORE_ADDR load_addr
, context_pc
= 0;
1445 struct field_of_this_result is_a_field_of_this
;
1448 error (_("Argument required."));
1450 sym
= lookup_symbol (exp
, get_selected_block (&context_pc
), VAR_DOMAIN
,
1451 &is_a_field_of_this
).symbol
;
1454 if (is_a_field_of_this
.type
!= NULL
)
1456 printf_filtered ("Symbol \"");
1457 fprintf_symbol_filtered (gdb_stdout
, exp
,
1458 current_language
->la_language
, DMGL_ANSI
);
1459 printf_filtered ("\" is a field of the local class variable ");
1460 if (current_language
->la_language
== language_objc
)
1461 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1463 printf_filtered ("`this'\n");
1467 msymbol
= lookup_bound_minimal_symbol (exp
);
1469 if (msymbol
.minsym
!= NULL
)
1471 struct objfile
*objfile
= msymbol
.objfile
;
1473 gdbarch
= get_objfile_arch (objfile
);
1474 load_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
1476 printf_filtered ("Symbol \"");
1477 fprintf_symbol_filtered (gdb_stdout
, exp
,
1478 current_language
->la_language
, DMGL_ANSI
);
1479 printf_filtered ("\" is at ");
1480 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1481 printf_filtered (" in a file compiled without debugging");
1482 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
1483 if (section_is_overlay (section
))
1485 load_addr
= overlay_unmapped_address (load_addr
, section
);
1486 printf_filtered (",\n -- loaded at ");
1487 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1488 printf_filtered (" in overlay section %s",
1489 section
->the_bfd_section
->name
);
1491 printf_filtered (".\n");
1494 error (_("No symbol \"%s\" in current context."), exp
);
1498 printf_filtered ("Symbol \"");
1499 fprintf_symbol_filtered (gdb_stdout
, SYMBOL_PRINT_NAME (sym
),
1500 current_language
->la_language
, DMGL_ANSI
);
1501 printf_filtered ("\" is ");
1502 val
= SYMBOL_VALUE (sym
);
1503 if (SYMBOL_OBJFILE_OWNED (sym
))
1504 section
= SYMBOL_OBJ_SECTION (symbol_objfile (sym
), sym
);
1507 gdbarch
= symbol_arch (sym
);
1509 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
1511 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, context_pc
,
1513 printf_filtered (".\n");
1517 switch (SYMBOL_CLASS (sym
))
1520 case LOC_CONST_BYTES
:
1521 printf_filtered ("constant");
1525 printf_filtered ("a label at address ");
1526 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1527 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1528 if (section_is_overlay (section
))
1530 load_addr
= overlay_unmapped_address (load_addr
, section
);
1531 printf_filtered (",\n -- loaded at ");
1532 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1533 printf_filtered (" in overlay section %s",
1534 section
->the_bfd_section
->name
);
1539 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
1542 /* GDBARCH is the architecture associated with the objfile the symbol
1543 is defined in; the target architecture may be different, and may
1544 provide additional registers. However, we do not know the target
1545 architecture at this point. We assume the objfile architecture
1546 will contain all the standard registers that occur in debug info
1548 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1550 if (SYMBOL_IS_ARGUMENT (sym
))
1551 printf_filtered (_("an argument in register %s"),
1552 gdbarch_register_name (gdbarch
, regno
));
1554 printf_filtered (_("a variable in register %s"),
1555 gdbarch_register_name (gdbarch
, regno
));
1559 printf_filtered (_("static storage at address "));
1560 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1561 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1562 if (section_is_overlay (section
))
1564 load_addr
= overlay_unmapped_address (load_addr
, section
);
1565 printf_filtered (_(",\n -- loaded at "));
1566 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1567 printf_filtered (_(" in overlay section %s"),
1568 section
->the_bfd_section
->name
);
1572 case LOC_REGPARM_ADDR
:
1573 /* Note comment at LOC_REGISTER. */
1574 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1575 printf_filtered (_("address of an argument in register %s"),
1576 gdbarch_register_name (gdbarch
, regno
));
1580 printf_filtered (_("an argument at offset %ld"), val
);
1584 printf_filtered (_("a local variable at frame offset %ld"), val
);
1588 printf_filtered (_("a reference argument at offset %ld"), val
);
1592 printf_filtered (_("a typedef"));
1596 printf_filtered (_("a function at address "));
1597 load_addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1598 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1599 if (section_is_overlay (section
))
1601 load_addr
= overlay_unmapped_address (load_addr
, section
);
1602 printf_filtered (_(",\n -- loaded at "));
1603 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1604 printf_filtered (_(" in overlay section %s"),
1605 section
->the_bfd_section
->name
);
1609 case LOC_UNRESOLVED
:
1611 struct bound_minimal_symbol msym
;
1613 msym
= lookup_minimal_symbol_and_objfile (SYMBOL_LINKAGE_NAME (sym
));
1614 if (msym
.minsym
== NULL
)
1615 printf_filtered ("unresolved");
1618 section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
1621 && (section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
1623 load_addr
= MSYMBOL_VALUE_RAW_ADDRESS (msym
.minsym
);
1624 printf_filtered (_("a thread-local variable at offset %s "
1625 "in the thread-local storage for `%s'"),
1626 paddress (gdbarch
, load_addr
),
1627 objfile_name (section
->objfile
));
1631 load_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
1632 printf_filtered (_("static storage at address "));
1633 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1634 if (section_is_overlay (section
))
1636 load_addr
= overlay_unmapped_address (load_addr
, section
);
1637 printf_filtered (_(",\n -- loaded at "));
1638 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1639 printf_filtered (_(" in overlay section %s"),
1640 section
->the_bfd_section
->name
);
1647 case LOC_OPTIMIZED_OUT
:
1648 printf_filtered (_("optimized out"));
1652 printf_filtered (_("of unknown (botched) type"));
1655 printf_filtered (".\n");
1660 x_command (char *exp
, int from_tty
)
1662 struct format_data fmt
;
1663 struct cleanup
*old_chain
;
1666 fmt
.format
= last_format
? last_format
: 'x';
1667 fmt
.size
= last_size
;
1671 if (exp
&& *exp
== '/')
1673 const char *tmp
= exp
+ 1;
1675 fmt
= decode_format (&tmp
, last_format
, last_size
);
1679 /* If we have an expression, evaluate it and use it as the address. */
1681 if (exp
!= 0 && *exp
!= 0)
1683 expression_up expr
= parse_expression (exp
);
1684 /* Cause expression not to be there any more if this command is
1685 repeated with Newline. But don't clobber a user-defined
1686 command's definition. */
1689 val
= evaluate_expression (expr
.get ());
1690 if (TYPE_IS_REFERENCE (value_type (val
)))
1691 val
= coerce_ref (val
);
1692 /* In rvalue contexts, such as this, functions are coerced into
1693 pointers to functions. This makes "x/i main" work. */
1694 if (/* last_format == 'i' && */
1695 TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
1696 && VALUE_LVAL (val
) == lval_memory
)
1697 next_address
= value_address (val
);
1699 next_address
= value_as_address (val
);
1701 next_gdbarch
= expr
->gdbarch
;
1705 error_no_arg (_("starting display address"));
1707 do_examine (fmt
, next_gdbarch
, next_address
);
1709 /* If the examine succeeds, we remember its size and format for next
1710 time. Set last_size to 'b' for strings. */
1711 if (fmt
.format
== 's')
1714 last_size
= fmt
.size
;
1715 last_format
= fmt
.format
;
1717 /* Set a couple of internal variables if appropriate. */
1718 if (last_examine_value
)
1720 /* Make last address examined available to the user as $_. Use
1721 the correct pointer type. */
1722 struct type
*pointer_type
1723 = lookup_pointer_type (value_type (last_examine_value
));
1724 set_internalvar (lookup_internalvar ("_"),
1725 value_from_pointer (pointer_type
,
1726 last_examine_address
));
1728 /* Make contents of last address examined available to the user
1729 as $__. If the last value has not been fetched from memory
1730 then don't fetch it now; instead mark it by voiding the $__
1732 if (value_lazy (last_examine_value
))
1733 clear_internalvar (lookup_internalvar ("__"));
1735 set_internalvar (lookup_internalvar ("__"), last_examine_value
);
1740 /* Add an expression to the auto-display chain.
1741 Specify the expression. */
1744 display_command (char *arg
, int from_tty
)
1746 struct format_data fmt
;
1747 struct display
*newobj
;
1748 const char *exp
= arg
;
1759 fmt
= decode_format (&exp
, 0, 0);
1760 if (fmt
.size
&& fmt
.format
== 0)
1762 if (fmt
.format
== 'i' || fmt
.format
== 's')
1773 innermost_block
= NULL
;
1774 expression_up expr
= parse_expression (exp
);
1776 newobj
= new display ();
1778 newobj
->exp_string
= xstrdup (exp
);
1779 newobj
->exp
= std::move (expr
);
1780 newobj
->block
= innermost_block
;
1781 newobj
->pspace
= current_program_space
;
1782 newobj
->number
= ++display_number
;
1783 newobj
->format
= fmt
;
1784 newobj
->enabled_p
= 1;
1785 newobj
->next
= NULL
;
1787 if (display_chain
== NULL
)
1788 display_chain
= newobj
;
1791 struct display
*last
;
1793 for (last
= display_chain
; last
->next
!= NULL
; last
= last
->next
)
1795 last
->next
= newobj
;
1799 do_one_display (newobj
);
1805 free_display (struct display
*d
)
1807 xfree (d
->exp_string
);
1811 /* Clear out the display_chain. Done when new symtabs are loaded,
1812 since this invalidates the types stored in many expressions. */
1815 clear_displays (void)
1819 while ((d
= display_chain
) != NULL
)
1821 display_chain
= d
->next
;
1826 /* Delete the auto-display DISPLAY. */
1829 delete_display (struct display
*display
)
1833 gdb_assert (display
!= NULL
);
1835 if (display_chain
== display
)
1836 display_chain
= display
->next
;
1839 if (d
->next
== display
)
1841 d
->next
= display
->next
;
1845 free_display (display
);
1848 /* Call FUNCTION on each of the displays whose numbers are given in
1849 ARGS. DATA is passed unmodified to FUNCTION. */
1852 map_display_numbers (char *args
,
1853 void (*function
) (struct display
*,
1860 error_no_arg (_("one or more display numbers"));
1862 number_or_range_parser
parser (args
);
1864 while (!parser
.finished ())
1866 const char *p
= parser
.cur_tok ();
1868 num
= parser
.get_number ();
1870 warning (_("bad display number at or near '%s'"), p
);
1873 struct display
*d
, *tmp
;
1875 ALL_DISPLAYS_SAFE (d
, tmp
)
1876 if (d
->number
== num
)
1879 printf_unfiltered (_("No display number %d.\n"), num
);
1886 /* Callback for map_display_numbers, that deletes a display. */
1889 do_delete_display (struct display
*d
, void *data
)
1894 /* "undisplay" command. */
1897 undisplay_command (char *args
, int from_tty
)
1901 if (query (_("Delete all auto-display expressions? ")))
1907 map_display_numbers (args
, do_delete_display
, NULL
);
1911 /* Display a single auto-display.
1912 Do nothing if the display cannot be printed in the current context,
1913 or if the display is disabled. */
1916 do_one_display (struct display
*d
)
1918 int within_current_scope
;
1920 if (d
->enabled_p
== 0)
1923 /* The expression carries the architecture that was used at parse time.
1924 This is a problem if the expression depends on architecture features
1925 (e.g. register numbers), and the current architecture is now different.
1926 For example, a display statement like "display/i $pc" is expected to
1927 display the PC register of the current architecture, not the arch at
1928 the time the display command was given. Therefore, we re-parse the
1929 expression if the current architecture has changed. */
1930 if (d
->exp
!= NULL
&& d
->exp
->gdbarch
!= get_current_arch ())
1941 innermost_block
= NULL
;
1942 d
->exp
= parse_expression (d
->exp_string
);
1943 d
->block
= innermost_block
;
1945 CATCH (ex
, RETURN_MASK_ALL
)
1947 /* Can't re-parse the expression. Disable this display item. */
1949 warning (_("Unable to display \"%s\": %s"),
1950 d
->exp_string
, ex
.message
);
1958 if (d
->pspace
== current_program_space
)
1959 within_current_scope
= contained_in (get_selected_block (0), d
->block
);
1961 within_current_scope
= 0;
1964 within_current_scope
= 1;
1965 if (!within_current_scope
)
1968 scoped_restore save_display_number
1969 = make_scoped_restore (¤t_display_number
, d
->number
);
1971 annotate_display_begin ();
1972 printf_filtered ("%d", d
->number
);
1973 annotate_display_number_end ();
1974 printf_filtered (": ");
1978 annotate_display_format ();
1980 printf_filtered ("x/");
1981 if (d
->format
.count
!= 1)
1982 printf_filtered ("%d", d
->format
.count
);
1983 printf_filtered ("%c", d
->format
.format
);
1984 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1985 printf_filtered ("%c", d
->format
.size
);
1986 printf_filtered (" ");
1988 annotate_display_expression ();
1990 puts_filtered (d
->exp_string
);
1991 annotate_display_expression_end ();
1993 if (d
->format
.count
!= 1 || d
->format
.format
== 'i')
1994 printf_filtered ("\n");
1996 printf_filtered (" ");
1998 annotate_display_value ();
2005 val
= evaluate_expression (d
->exp
.get ());
2006 addr
= value_as_address (val
);
2007 if (d
->format
.format
== 'i')
2008 addr
= gdbarch_addr_bits_remove (d
->exp
->gdbarch
, addr
);
2009 do_examine (d
->format
, d
->exp
->gdbarch
, addr
);
2011 CATCH (ex
, RETURN_MASK_ERROR
)
2013 fprintf_filtered (gdb_stdout
, _("<error: %s>\n"), ex
.message
);
2019 struct value_print_options opts
;
2021 annotate_display_format ();
2023 if (d
->format
.format
)
2024 printf_filtered ("/%c ", d
->format
.format
);
2026 annotate_display_expression ();
2028 puts_filtered (d
->exp_string
);
2029 annotate_display_expression_end ();
2031 printf_filtered (" = ");
2033 annotate_display_expression ();
2035 get_formatted_print_options (&opts
, d
->format
.format
);
2036 opts
.raw
= d
->format
.raw
;
2042 val
= evaluate_expression (d
->exp
.get ());
2043 print_formatted (val
, d
->format
.size
, &opts
, gdb_stdout
);
2045 CATCH (ex
, RETURN_MASK_ERROR
)
2047 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
2051 printf_filtered ("\n");
2054 annotate_display_end ();
2056 gdb_flush (gdb_stdout
);
2059 /* Display all of the values on the auto-display chain which can be
2060 evaluated in the current scope. */
2067 for (d
= display_chain
; d
; d
= d
->next
)
2071 /* Delete the auto-display which we were in the process of displaying.
2072 This is done when there is an error or a signal. */
2075 disable_display (int num
)
2079 for (d
= display_chain
; d
; d
= d
->next
)
2080 if (d
->number
== num
)
2085 printf_unfiltered (_("No display number %d.\n"), num
);
2089 disable_current_display (void)
2091 if (current_display_number
>= 0)
2093 disable_display (current_display_number
);
2094 fprintf_unfiltered (gdb_stderr
,
2095 _("Disabling display %d to "
2096 "avoid infinite recursion.\n"),
2097 current_display_number
);
2099 current_display_number
= -1;
2103 display_info (char *ignore
, int from_tty
)
2108 printf_unfiltered (_("There are no auto-display expressions now.\n"));
2110 printf_filtered (_("Auto-display expressions now in effect:\n\
2111 Num Enb Expression\n"));
2113 for (d
= display_chain
; d
; d
= d
->next
)
2115 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
2117 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
2119 else if (d
->format
.format
)
2120 printf_filtered ("/%c ", d
->format
.format
);
2121 puts_filtered (d
->exp_string
);
2122 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
))
2123 printf_filtered (_(" (cannot be evaluated in the current context)"));
2124 printf_filtered ("\n");
2125 gdb_flush (gdb_stdout
);
2129 /* Callback fo map_display_numbers, that enables or disables the
2130 passed in display D. */
2133 do_enable_disable_display (struct display
*d
, void *data
)
2135 d
->enabled_p
= *(int *) data
;
2138 /* Implamentation of both the "disable display" and "enable display"
2139 commands. ENABLE decides what to do. */
2142 enable_disable_display_command (char *args
, int from_tty
, int enable
)
2149 d
->enabled_p
= enable
;
2153 map_display_numbers (args
, do_enable_disable_display
, &enable
);
2156 /* The "enable display" command. */
2159 enable_display_command (char *args
, int from_tty
)
2161 enable_disable_display_command (args
, from_tty
, 1);
2164 /* The "disable display" command. */
2167 disable_display_command (char *args
, int from_tty
)
2169 enable_disable_display_command (args
, from_tty
, 0);
2172 /* display_chain items point to blocks and expressions. Some expressions in
2173 turn may point to symbols.
2174 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
2175 obstack_free'd when a shared library is unloaded.
2176 Clear pointers that are about to become dangling.
2177 Both .exp and .block fields will be restored next time we need to display
2178 an item by re-parsing .exp_string field in the new execution context. */
2181 clear_dangling_display_expressions (struct objfile
*objfile
)
2184 struct program_space
*pspace
;
2186 /* With no symbol file we cannot have a block or expression from it. */
2187 if (objfile
== NULL
)
2189 pspace
= objfile
->pspace
;
2190 if (objfile
->separate_debug_objfile_backlink
)
2192 objfile
= objfile
->separate_debug_objfile_backlink
;
2193 gdb_assert (objfile
->pspace
== pspace
);
2196 for (d
= display_chain
; d
!= NULL
; d
= d
->next
)
2198 if (d
->pspace
!= pspace
)
2201 if (lookup_objfile_from_block (d
->block
) == objfile
2202 || (d
->exp
!= NULL
&& exp_uses_objfile (d
->exp
.get (), objfile
)))
2211 /* Print the value in stack frame FRAME of a variable specified by a
2212 struct symbol. NAME is the name to print; if NULL then VAR's print
2213 name will be used. STREAM is the ui_file on which to print the
2214 value. INDENT specifies the number of indent levels to print
2215 before printing the variable name.
2217 This function invalidates FRAME. */
2220 print_variable_and_value (const char *name
, struct symbol
*var
,
2221 struct frame_info
*frame
,
2222 struct ui_file
*stream
, int indent
)
2226 name
= SYMBOL_PRINT_NAME (var
);
2228 fprintf_filtered (stream
, "%s%s = ", n_spaces (2 * indent
), name
);
2232 struct value_print_options opts
;
2234 /* READ_VAR_VALUE needs a block in order to deal with non-local
2235 references (i.e. to handle nested functions). In this context, we
2236 print variables that are local to this frame, so we can avoid passing
2238 val
= read_var_value (var
, NULL
, frame
);
2239 get_user_print_options (&opts
);
2241 common_val_print (val
, stream
, indent
, &opts
, current_language
);
2243 /* common_val_print invalidates FRAME when a pretty printer calls inferior
2247 CATCH (except
, RETURN_MASK_ERROR
)
2249 fprintf_filtered(stream
, "<error reading variable %s (%s)>", name
,
2254 fprintf_filtered (stream
, "\n");
2257 /* Subroutine of ui_printf to simplify it.
2258 Print VALUE to STREAM using FORMAT.
2259 VALUE is a C-style string on the target. */
2262 printf_c_string (struct ui_file
*stream
, const char *format
,
2263 struct value
*value
)
2269 tem
= value_as_address (value
);
2271 /* This is a %s argument. Find the length of the string. */
2277 read_memory (tem
+ j
, &c
, 1);
2282 /* Copy the string contents into a string inside GDB. */
2283 str
= (gdb_byte
*) alloca (j
+ 1);
2285 read_memory (tem
, str
, j
);
2288 fprintf_filtered (stream
, format
, (char *) str
);
2291 /* Subroutine of ui_printf to simplify it.
2292 Print VALUE to STREAM using FORMAT.
2293 VALUE is a wide C-style string on the target. */
2296 printf_wide_c_string (struct ui_file
*stream
, const char *format
,
2297 struct value
*value
)
2302 struct gdbarch
*gdbarch
= get_type_arch (value_type (value
));
2303 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2304 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2305 "wchar_t", NULL
, 0);
2306 int wcwidth
= TYPE_LENGTH (wctype
);
2307 gdb_byte
*buf
= (gdb_byte
*) alloca (wcwidth
);
2308 struct obstack output
;
2309 struct cleanup
*inner_cleanup
;
2311 tem
= value_as_address (value
);
2313 /* This is a %s argument. Find the length of the string. */
2314 for (j
= 0;; j
+= wcwidth
)
2317 read_memory (tem
+ j
, buf
, wcwidth
);
2318 if (extract_unsigned_integer (buf
, wcwidth
, byte_order
) == 0)
2322 /* Copy the string contents into a string inside GDB. */
2323 str
= (gdb_byte
*) alloca (j
+ wcwidth
);
2325 read_memory (tem
, str
, j
);
2326 memset (&str
[j
], 0, wcwidth
);
2328 obstack_init (&output
);
2329 inner_cleanup
= make_cleanup_obstack_free (&output
);
2331 convert_between_encodings (target_wide_charset (gdbarch
),
2334 &output
, translit_char
);
2335 obstack_grow_str0 (&output
, "");
2337 fprintf_filtered (stream
, format
, obstack_base (&output
));
2338 do_cleanups (inner_cleanup
);
2341 /* Subroutine of ui_printf to simplify it.
2342 Print VALUE, a decimal floating point value, to STREAM using FORMAT. */
2345 printf_decfloat (struct ui_file
*stream
, const char *format
,
2346 struct value
*value
)
2348 const gdb_byte
*param_ptr
= value_contents (value
);
2350 #if defined (PRINTF_HAS_DECFLOAT)
2351 /* If we have native support for Decimal floating
2352 printing, handle it here. */
2353 fprintf_filtered (stream
, format
, param_ptr
);
2355 /* As a workaround until vasprintf has native support for DFP
2356 we convert the DFP values to string and print them using
2357 the %s format specifier. */
2360 /* Parameter data. */
2361 struct type
*param_type
= value_type (value
);
2362 struct gdbarch
*gdbarch
= get_type_arch (param_type
);
2363 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2365 /* DFP output data. */
2366 struct value
*dfp_value
= NULL
;
2370 struct type
*dfp_type
= NULL
;
2371 char decstr
[MAX_DECIMAL_STRING
];
2373 /* Points to the end of the string so that we can go back
2374 and check for DFP length modifiers. */
2375 p
= format
+ strlen (format
);
2377 /* Look for the float/double format specifier. */
2378 while (*p
!= 'f' && *p
!= 'e' && *p
!= 'E'
2379 && *p
!= 'g' && *p
!= 'G')
2382 /* Search for the '%' char and extract the size and type of
2383 the output decimal value based on its modifiers
2384 (%Hf, %Df, %DDf). */
2390 dfp_type
= builtin_type (gdbarch
)->builtin_decfloat
;
2392 else if (*p
== 'D' && *(p
- 1) == 'D')
2395 dfp_type
= builtin_type (gdbarch
)->builtin_declong
;
2401 dfp_type
= builtin_type (gdbarch
)->builtin_decdouble
;
2405 /* Conversion between different DFP types. */
2406 if (TYPE_CODE (param_type
) == TYPE_CODE_DECFLOAT
)
2407 decimal_convert (param_ptr
, TYPE_LENGTH (param_type
),
2408 byte_order
, dec
, dfp_len
, byte_order
);
2410 /* If this is a non-trivial conversion, just output 0.
2411 A correct converted value can be displayed by explicitly
2412 casting to a DFP type. */
2413 decimal_from_string (dec
, dfp_len
, byte_order
, "0");
2415 dfp_value
= value_from_decfloat (dfp_type
, dec
);
2417 dfp_ptr
= (gdb_byte
*) value_contents (dfp_value
);
2419 decimal_to_string (dfp_ptr
, dfp_len
, byte_order
, decstr
);
2421 /* Print the DFP value. */
2422 fprintf_filtered (stream
, "%s", decstr
);
2426 /* Subroutine of ui_printf to simplify it.
2427 Print VALUE, a target pointer, to STREAM using FORMAT. */
2430 printf_pointer (struct ui_file
*stream
, const char *format
,
2431 struct value
*value
)
2433 /* We avoid the host's %p because pointers are too
2434 likely to be the wrong size. The only interesting
2435 modifier for %p is a width; extract that, and then
2436 handle %p as glibc would: %#x or a literal "(nil)". */
2440 #ifdef PRINTF_HAS_LONG_LONG
2441 long long val
= value_as_long (value
);
2443 long val
= value_as_long (value
);
2446 fmt
= (char *) alloca (strlen (format
) + 5);
2448 /* Copy up to the leading %. */
2453 int is_percent
= (*p
== '%');
2468 /* Copy any width. */
2469 while (*p
>= '0' && *p
< '9')
2472 gdb_assert (*p
== 'p' && *(p
+ 1) == '\0');
2475 #ifdef PRINTF_HAS_LONG_LONG
2481 fprintf_filtered (stream
, fmt
, val
);
2487 fprintf_filtered (stream
, fmt
, "(nil)");
2491 /* printf "printf format string" ARG to STREAM. */
2494 ui_printf (const char *arg
, struct ui_file
*stream
)
2496 struct format_piece
*fpieces
;
2497 const char *s
= arg
;
2498 struct value
**val_args
;
2499 int allocated_args
= 20;
2500 struct cleanup
*old_cleanups
;
2502 val_args
= XNEWVEC (struct value
*, allocated_args
);
2503 old_cleanups
= make_cleanup (free_current_contents
, &val_args
);
2506 error_no_arg (_("format-control string and values to print"));
2508 s
= skip_spaces_const (s
);
2510 /* A format string should follow, enveloped in double quotes. */
2512 error (_("Bad format string, missing '\"'."));
2514 fpieces
= parse_format_string (&s
);
2516 make_cleanup (free_format_pieces_cleanup
, &fpieces
);
2519 error (_("Bad format string, non-terminated '\"'."));
2521 s
= skip_spaces_const (s
);
2523 if (*s
!= ',' && *s
!= 0)
2524 error (_("Invalid argument syntax"));
2528 s
= skip_spaces_const (s
);
2534 char *current_substring
;
2537 for (fr
= 0; fpieces
[fr
].string
!= NULL
; fr
++)
2538 if (fpieces
[fr
].argclass
!= literal_piece
)
2541 /* Now, parse all arguments and evaluate them.
2542 Store the VALUEs in VAL_ARGS. */
2548 if (nargs
== allocated_args
)
2549 val_args
= (struct value
**) xrealloc ((char *) val_args
,
2550 (allocated_args
*= 2)
2551 * sizeof (struct value
*));
2553 val_args
[nargs
] = parse_to_comma_and_eval (&s1
);
2561 if (nargs
!= nargs_wanted
)
2562 error (_("Wrong number of arguments for specified format-string"));
2564 /* Now actually print them. */
2566 for (fr
= 0; fpieces
[fr
].string
!= NULL
; fr
++)
2568 current_substring
= fpieces
[fr
].string
;
2569 switch (fpieces
[fr
].argclass
)
2572 printf_c_string (stream
, current_substring
, val_args
[i
]);
2574 case wide_string_arg
:
2575 printf_wide_c_string (stream
, current_substring
, val_args
[i
]);
2579 struct gdbarch
*gdbarch
2580 = get_type_arch (value_type (val_args
[i
]));
2581 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2582 "wchar_t", NULL
, 0);
2583 struct type
*valtype
;
2584 struct obstack output
;
2585 struct cleanup
*inner_cleanup
;
2586 const gdb_byte
*bytes
;
2588 valtype
= value_type (val_args
[i
]);
2589 if (TYPE_LENGTH (valtype
) != TYPE_LENGTH (wctype
)
2590 || TYPE_CODE (valtype
) != TYPE_CODE_INT
)
2591 error (_("expected wchar_t argument for %%lc"));
2593 bytes
= value_contents (val_args
[i
]);
2595 obstack_init (&output
);
2596 inner_cleanup
= make_cleanup_obstack_free (&output
);
2598 convert_between_encodings (target_wide_charset (gdbarch
),
2600 bytes
, TYPE_LENGTH (valtype
),
2601 TYPE_LENGTH (valtype
),
2602 &output
, translit_char
);
2603 obstack_grow_str0 (&output
, "");
2605 fprintf_filtered (stream
, current_substring
,
2606 obstack_base (&output
));
2607 do_cleanups (inner_cleanup
);
2612 struct type
*type
= value_type (val_args
[i
]);
2616 /* If format string wants a float, unchecked-convert the value
2617 to floating point of the same size. */
2618 type
= float_type_from_length (type
);
2619 val
= unpack_double (type
, value_contents (val_args
[i
]), &inv
);
2621 error (_("Invalid floating value found in program."));
2623 fprintf_filtered (stream
, current_substring
, (double) val
);
2626 case long_double_arg
:
2627 #ifdef HAVE_LONG_DOUBLE
2629 struct type
*type
= value_type (val_args
[i
]);
2633 /* If format string wants a float, unchecked-convert the value
2634 to floating point of the same size. */
2635 type
= float_type_from_length (type
);
2636 val
= unpack_double (type
, value_contents (val_args
[i
]), &inv
);
2638 error (_("Invalid floating value found in program."));
2640 fprintf_filtered (stream
, current_substring
,
2645 error (_("long double not supported in printf"));
2648 #ifdef PRINTF_HAS_LONG_LONG
2650 long long val
= value_as_long (val_args
[i
]);
2652 fprintf_filtered (stream
, current_substring
, val
);
2656 error (_("long long not supported in printf"));
2660 int val
= value_as_long (val_args
[i
]);
2662 fprintf_filtered (stream
, current_substring
, val
);
2667 long val
= value_as_long (val_args
[i
]);
2669 fprintf_filtered (stream
, current_substring
, val
);
2672 /* Handles decimal floating values. */
2674 printf_decfloat (stream
, current_substring
, val_args
[i
]);
2677 printf_pointer (stream
, current_substring
, val_args
[i
]);
2680 /* Print a portion of the format string that has no
2681 directives. Note that this will not include any
2682 ordinary %-specs, but it might include "%%". That is
2683 why we use printf_filtered and not puts_filtered here.
2684 Also, we pass a dummy argument because some platforms
2685 have modified GCC to include -Wformat-security by
2686 default, which will warn here if there is no
2688 fprintf_filtered (stream
, current_substring
, 0);
2691 internal_error (__FILE__
, __LINE__
,
2692 _("failed internal consistency check"));
2694 /* Maybe advance to the next argument. */
2695 if (fpieces
[fr
].argclass
!= literal_piece
)
2699 do_cleanups (old_cleanups
);
2702 /* Implement the "printf" command. */
2705 printf_command (char *arg
, int from_tty
)
2707 ui_printf (arg
, gdb_stdout
);
2708 gdb_flush (gdb_stdout
);
2711 /* Implement the "eval" command. */
2714 eval_command (char *arg
, int from_tty
)
2718 ui_printf (arg
, &stb
);
2720 std::string expanded
= insert_user_defined_cmd_args (stb
.c_str ());
2722 execute_command (&expanded
[0], from_tty
);
2726 _initialize_printcmd (void)
2728 struct cmd_list_element
*c
;
2730 current_display_number
= -1;
2732 observer_attach_free_objfile (clear_dangling_display_expressions
);
2734 add_info ("address", address_info
,
2735 _("Describe where symbol SYM is stored."));
2737 add_info ("symbol", sym_info
, _("\
2738 Describe what symbol is at location ADDR.\n\
2739 Only for symbols with fixed locations (global or static scope)."));
2741 add_com ("x", class_vars
, x_command
, _("\
2742 Examine memory: x/FMT ADDRESS.\n\
2743 ADDRESS is an expression for the memory address to examine.\n\
2744 FMT is a repeat count followed by a format letter and a size letter.\n\
2745 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2746 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2747 and z(hex, zero padded on the left).\n\
2748 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2749 The specified number of objects of the specified size are printed\n\
2750 according to the format. If a negative number is specified, memory is\n\
2751 examined backward from the address.\n\n\
2752 Defaults for format and size letters are those previously used.\n\
2753 Default count is 1. Default address is following last thing printed\n\
2754 with this command or \"print\"."));
2757 add_com ("whereis", class_vars
, whereis_command
,
2758 _("Print line number and file of definition of variable."));
2761 add_info ("display", display_info
, _("\
2762 Expressions to display when program stops, with code numbers."));
2764 add_cmd ("undisplay", class_vars
, undisplay_command
, _("\
2765 Cancel some expressions to be displayed when program stops.\n\
2766 Arguments are the code numbers of the expressions to stop displaying.\n\
2767 No argument means cancel all automatic-display expressions.\n\
2768 \"delete display\" has the same effect as this command.\n\
2769 Do \"info display\" to see current list of code numbers."),
2772 add_com ("display", class_vars
, display_command
, _("\
2773 Print value of expression EXP each time the program stops.\n\
2774 /FMT may be used before EXP as in the \"print\" command.\n\
2775 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2776 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2777 and examining is done as in the \"x\" command.\n\n\
2778 With no argument, display all currently requested auto-display expressions.\n\
2779 Use \"undisplay\" to cancel display requests previously made."));
2781 add_cmd ("display", class_vars
, enable_display_command
, _("\
2782 Enable some expressions to be displayed when program stops.\n\
2783 Arguments are the code numbers of the expressions to resume displaying.\n\
2784 No argument means enable all automatic-display expressions.\n\
2785 Do \"info display\" to see current list of code numbers."), &enablelist
);
2787 add_cmd ("display", class_vars
, disable_display_command
, _("\
2788 Disable some expressions to be displayed when program stops.\n\
2789 Arguments are the code numbers of the expressions to stop displaying.\n\
2790 No argument means disable all automatic-display expressions.\n\
2791 Do \"info display\" to see current list of code numbers."), &disablelist
);
2793 add_cmd ("display", class_vars
, undisplay_command
, _("\
2794 Cancel some expressions to be displayed when program stops.\n\
2795 Arguments are the code numbers of the expressions to stop displaying.\n\
2796 No argument means cancel all automatic-display expressions.\n\
2797 Do \"info display\" to see current list of code numbers."), &deletelist
);
2799 add_com ("printf", class_vars
, printf_command
, _("\
2800 printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2801 This is useful for formatted output in user-defined commands."));
2803 add_com ("output", class_vars
, output_command
, _("\
2804 Like \"print\" but don't put in value history and don't print newline.\n\
2805 This is useful in user-defined commands."));
2807 add_prefix_cmd ("set", class_vars
, set_command
, _("\
2808 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2809 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2810 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2811 with $), a register (a few standard names starting with $), or an actual\n\
2812 variable in the program being debugged. EXP is any valid expression.\n\
2813 Use \"set variable\" for variables with names identical to set subcommands.\n\
2815 With a subcommand, this command modifies parts of the gdb environment.\n\
2816 You can see these environment settings with the \"show\" command."),
2817 &setlist
, "set ", 1, &cmdlist
);
2819 add_com ("assign", class_vars
, set_command
, _("\
2820 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2821 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2822 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2823 with $), a register (a few standard names starting with $), or an actual\n\
2824 variable in the program being debugged. EXP is any valid expression.\n\
2825 Use \"set variable\" for variables with names identical to set subcommands.\n\
2826 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2827 You can see these environment settings with the \"show\" command."));
2829 /* "call" is the same as "set", but handy for dbx users to call fns. */
2830 c
= add_com ("call", class_vars
, call_command
, _("\
2831 Call a function in the program.\n\
2832 The argument is the function name and arguments, in the notation of the\n\
2833 current working language. The result is printed and saved in the value\n\
2834 history, if it is not void."));
2835 set_cmd_completer (c
, expression_completer
);
2837 add_cmd ("variable", class_vars
, set_command
, _("\
2838 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2839 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2840 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2841 with $), a register (a few standard names starting with $), or an actual\n\
2842 variable in the program being debugged. EXP is any valid expression.\n\
2843 This may usually be abbreviated to simply \"set\"."),
2846 c
= add_com ("print", class_vars
, print_command
, _("\
2847 Print value of expression EXP.\n\
2848 Variables accessible are those of the lexical environment of the selected\n\
2849 stack frame, plus all those whose scope is global or an entire file.\n\
2851 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2852 $$NUM refers to NUM'th value back from the last one.\n\
2853 Names starting with $ refer to registers (with the values they would have\n\
2854 if the program were to return to the stack frame now selected, restoring\n\
2855 all registers saved by frames farther in) or else to debugger\n\
2856 \"convenience\" variables (any such name not a known register).\n\
2857 Use assignment expressions to give values to convenience variables.\n\
2859 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2860 @ is a binary operator for treating consecutive data objects\n\
2861 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2862 element is FOO, whose second element is stored in the space following\n\
2863 where FOO is stored, etc. FOO must be an expression whose value\n\
2864 resides in memory.\n\
2866 EXP may be preceded with /FMT, where FMT is a format letter\n\
2867 but no count or size letter (see \"x\" command)."));
2868 set_cmd_completer (c
, expression_completer
);
2869 add_com_alias ("p", "print", class_vars
, 1);
2870 add_com_alias ("inspect", "print", class_vars
, 1);
2872 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class
,
2873 &max_symbolic_offset
, _("\
2874 Set the largest offset that will be printed in <symbol+1234> form."), _("\
2875 Show the largest offset that will be printed in <symbol+1234> form."), _("\
2876 Tell GDB to only display the symbolic form of an address if the\n\
2877 offset between the closest earlier symbol and the address is less than\n\
2878 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
2879 to always print the symbolic form of an address if any symbol precedes\n\
2880 it. Zero is equivalent to \"unlimited\"."),
2882 show_max_symbolic_offset
,
2883 &setprintlist
, &showprintlist
);
2884 add_setshow_boolean_cmd ("symbol-filename", no_class
,
2885 &print_symbol_filename
, _("\
2886 Set printing of source filename and line number with <symbol>."), _("\
2887 Show printing of source filename and line number with <symbol>."), NULL
,
2889 show_print_symbol_filename
,
2890 &setprintlist
, &showprintlist
);
2892 add_com ("eval", no_class
, eval_command
, _("\
2893 Convert \"printf format string\", arg1, arg2, arg3, ..., argn to\n\
2894 a command line, and call it."));