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 (const 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 ());
1288 /* Temporary non-const version of set_command. */
1291 non_const_set_command (char *exp
, int from_tty
)
1293 set_command (exp
, from_tty
);
1297 info_symbol_command (char *arg
, int from_tty
)
1299 struct minimal_symbol
*msymbol
;
1300 struct objfile
*objfile
;
1301 struct obj_section
*osect
;
1302 CORE_ADDR addr
, sect_addr
;
1304 unsigned int offset
;
1307 error_no_arg (_("address"));
1309 addr
= parse_and_eval_address (arg
);
1310 ALL_OBJSECTIONS (objfile
, osect
)
1312 /* Only process each object file once, even if there's a separate
1314 if (objfile
->separate_debug_objfile_backlink
)
1317 sect_addr
= overlay_mapped_address (addr
, osect
);
1319 if (obj_section_addr (osect
) <= sect_addr
1320 && sect_addr
< obj_section_endaddr (osect
)
1322 = lookup_minimal_symbol_by_pc_section (sect_addr
, osect
).minsym
))
1324 const char *obj_name
, *mapped
, *sec_name
, *msym_name
;
1325 const char *loc_string
;
1326 struct cleanup
*old_chain
;
1329 offset
= sect_addr
- MSYMBOL_VALUE_ADDRESS (objfile
, msymbol
);
1330 mapped
= section_is_mapped (osect
) ? _("mapped") : _("unmapped");
1331 sec_name
= osect
->the_bfd_section
->name
;
1332 msym_name
= MSYMBOL_PRINT_NAME (msymbol
);
1334 /* Don't print the offset if it is zero.
1335 We assume there's no need to handle i18n of "sym + offset". */
1336 std::string string_holder
;
1339 string_holder
= string_printf ("%s + %u", msym_name
, offset
);
1340 loc_string
= string_holder
.c_str ();
1343 loc_string
= msym_name
;
1345 gdb_assert (osect
->objfile
&& objfile_name (osect
->objfile
));
1346 obj_name
= objfile_name (osect
->objfile
);
1348 if (MULTI_OBJFILE_P ())
1349 if (pc_in_unmapped_range (addr
, osect
))
1350 if (section_is_overlay (osect
))
1351 printf_filtered (_("%s in load address range of "
1352 "%s overlay section %s of %s\n"),
1353 loc_string
, mapped
, sec_name
, obj_name
);
1355 printf_filtered (_("%s in load address range of "
1356 "section %s of %s\n"),
1357 loc_string
, sec_name
, obj_name
);
1359 if (section_is_overlay (osect
))
1360 printf_filtered (_("%s in %s overlay section %s of %s\n"),
1361 loc_string
, mapped
, sec_name
, obj_name
);
1363 printf_filtered (_("%s in section %s of %s\n"),
1364 loc_string
, sec_name
, obj_name
);
1366 if (pc_in_unmapped_range (addr
, osect
))
1367 if (section_is_overlay (osect
))
1368 printf_filtered (_("%s in load address range of %s overlay "
1370 loc_string
, mapped
, sec_name
);
1372 printf_filtered (_("%s in load address range of section %s\n"),
1373 loc_string
, sec_name
);
1375 if (section_is_overlay (osect
))
1376 printf_filtered (_("%s in %s overlay section %s\n"),
1377 loc_string
, mapped
, sec_name
);
1379 printf_filtered (_("%s in section %s\n"),
1380 loc_string
, sec_name
);
1384 printf_filtered (_("No symbol matches %s.\n"), arg
);
1388 info_address_command (char *exp
, int from_tty
)
1390 struct gdbarch
*gdbarch
;
1393 struct bound_minimal_symbol msymbol
;
1395 struct obj_section
*section
;
1396 CORE_ADDR load_addr
, context_pc
= 0;
1397 struct field_of_this_result is_a_field_of_this
;
1400 error (_("Argument required."));
1402 sym
= lookup_symbol (exp
, get_selected_block (&context_pc
), VAR_DOMAIN
,
1403 &is_a_field_of_this
).symbol
;
1406 if (is_a_field_of_this
.type
!= NULL
)
1408 printf_filtered ("Symbol \"");
1409 fprintf_symbol_filtered (gdb_stdout
, exp
,
1410 current_language
->la_language
, DMGL_ANSI
);
1411 printf_filtered ("\" is a field of the local class variable ");
1412 if (current_language
->la_language
== language_objc
)
1413 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1415 printf_filtered ("`this'\n");
1419 msymbol
= lookup_bound_minimal_symbol (exp
);
1421 if (msymbol
.minsym
!= NULL
)
1423 struct objfile
*objfile
= msymbol
.objfile
;
1425 gdbarch
= get_objfile_arch (objfile
);
1426 load_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
1428 printf_filtered ("Symbol \"");
1429 fprintf_symbol_filtered (gdb_stdout
, exp
,
1430 current_language
->la_language
, DMGL_ANSI
);
1431 printf_filtered ("\" is at ");
1432 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1433 printf_filtered (" in a file compiled without debugging");
1434 section
= MSYMBOL_OBJ_SECTION (objfile
, msymbol
.minsym
);
1435 if (section_is_overlay (section
))
1437 load_addr
= overlay_unmapped_address (load_addr
, section
);
1438 printf_filtered (",\n -- loaded at ");
1439 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1440 printf_filtered (" in overlay section %s",
1441 section
->the_bfd_section
->name
);
1443 printf_filtered (".\n");
1446 error (_("No symbol \"%s\" in current context."), exp
);
1450 printf_filtered ("Symbol \"");
1451 fprintf_symbol_filtered (gdb_stdout
, SYMBOL_PRINT_NAME (sym
),
1452 current_language
->la_language
, DMGL_ANSI
);
1453 printf_filtered ("\" is ");
1454 val
= SYMBOL_VALUE (sym
);
1455 if (SYMBOL_OBJFILE_OWNED (sym
))
1456 section
= SYMBOL_OBJ_SECTION (symbol_objfile (sym
), sym
);
1459 gdbarch
= symbol_arch (sym
);
1461 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
1463 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, context_pc
,
1465 printf_filtered (".\n");
1469 switch (SYMBOL_CLASS (sym
))
1472 case LOC_CONST_BYTES
:
1473 printf_filtered ("constant");
1477 printf_filtered ("a label at address ");
1478 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1479 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1480 if (section_is_overlay (section
))
1482 load_addr
= overlay_unmapped_address (load_addr
, section
);
1483 printf_filtered (",\n -- loaded at ");
1484 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1485 printf_filtered (" in overlay section %s",
1486 section
->the_bfd_section
->name
);
1491 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
1494 /* GDBARCH is the architecture associated with the objfile the symbol
1495 is defined in; the target architecture may be different, and may
1496 provide additional registers. However, we do not know the target
1497 architecture at this point. We assume the objfile architecture
1498 will contain all the standard registers that occur in debug info
1500 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1502 if (SYMBOL_IS_ARGUMENT (sym
))
1503 printf_filtered (_("an argument in register %s"),
1504 gdbarch_register_name (gdbarch
, regno
));
1506 printf_filtered (_("a variable in register %s"),
1507 gdbarch_register_name (gdbarch
, regno
));
1511 printf_filtered (_("static storage at address "));
1512 load_addr
= SYMBOL_VALUE_ADDRESS (sym
);
1513 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1514 if (section_is_overlay (section
))
1516 load_addr
= overlay_unmapped_address (load_addr
, section
);
1517 printf_filtered (_(",\n -- loaded at "));
1518 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1519 printf_filtered (_(" in overlay section %s"),
1520 section
->the_bfd_section
->name
);
1524 case LOC_REGPARM_ADDR
:
1525 /* Note comment at LOC_REGISTER. */
1526 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1527 printf_filtered (_("address of an argument in register %s"),
1528 gdbarch_register_name (gdbarch
, regno
));
1532 printf_filtered (_("an argument at offset %ld"), val
);
1536 printf_filtered (_("a local variable at frame offset %ld"), val
);
1540 printf_filtered (_("a reference argument at offset %ld"), val
);
1544 printf_filtered (_("a typedef"));
1548 printf_filtered (_("a function at address "));
1549 load_addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1550 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1551 if (section_is_overlay (section
))
1553 load_addr
= overlay_unmapped_address (load_addr
, section
);
1554 printf_filtered (_(",\n -- loaded at "));
1555 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1556 printf_filtered (_(" in overlay section %s"),
1557 section
->the_bfd_section
->name
);
1561 case LOC_UNRESOLVED
:
1563 struct bound_minimal_symbol msym
;
1565 msym
= lookup_minimal_symbol_and_objfile (SYMBOL_LINKAGE_NAME (sym
));
1566 if (msym
.minsym
== NULL
)
1567 printf_filtered ("unresolved");
1570 section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
1573 && (section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
1575 load_addr
= MSYMBOL_VALUE_RAW_ADDRESS (msym
.minsym
);
1576 printf_filtered (_("a thread-local variable at offset %s "
1577 "in the thread-local storage for `%s'"),
1578 paddress (gdbarch
, load_addr
),
1579 objfile_name (section
->objfile
));
1583 load_addr
= BMSYMBOL_VALUE_ADDRESS (msym
);
1584 printf_filtered (_("static storage at address "));
1585 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1586 if (section_is_overlay (section
))
1588 load_addr
= overlay_unmapped_address (load_addr
, section
);
1589 printf_filtered (_(",\n -- loaded at "));
1590 fputs_filtered (paddress (gdbarch
, load_addr
), gdb_stdout
);
1591 printf_filtered (_(" in overlay section %s"),
1592 section
->the_bfd_section
->name
);
1599 case LOC_OPTIMIZED_OUT
:
1600 printf_filtered (_("optimized out"));
1604 printf_filtered (_("of unknown (botched) type"));
1607 printf_filtered (".\n");
1612 x_command (char *exp
, int from_tty
)
1614 struct format_data fmt
;
1617 fmt
.format
= last_format
? last_format
: 'x';
1618 fmt
.size
= last_size
;
1622 if (exp
&& *exp
== '/')
1624 const char *tmp
= exp
+ 1;
1626 fmt
= decode_format (&tmp
, last_format
, last_size
);
1630 /* If we have an expression, evaluate it and use it as the address. */
1632 if (exp
!= 0 && *exp
!= 0)
1634 expression_up expr
= parse_expression (exp
);
1635 /* Cause expression not to be there any more if this command is
1636 repeated with Newline. But don't clobber a user-defined
1637 command's definition. */
1640 val
= evaluate_expression (expr
.get ());
1641 if (TYPE_IS_REFERENCE (value_type (val
)))
1642 val
= coerce_ref (val
);
1643 /* In rvalue contexts, such as this, functions are coerced into
1644 pointers to functions. This makes "x/i main" work. */
1645 if (/* last_format == 'i' && */
1646 TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
1647 && VALUE_LVAL (val
) == lval_memory
)
1648 next_address
= value_address (val
);
1650 next_address
= value_as_address (val
);
1652 next_gdbarch
= expr
->gdbarch
;
1656 error_no_arg (_("starting display address"));
1658 do_examine (fmt
, next_gdbarch
, next_address
);
1660 /* If the examine succeeds, we remember its size and format for next
1661 time. Set last_size to 'b' for strings. */
1662 if (fmt
.format
== 's')
1665 last_size
= fmt
.size
;
1666 last_format
= fmt
.format
;
1668 /* Set a couple of internal variables if appropriate. */
1669 if (last_examine_value
)
1671 /* Make last address examined available to the user as $_. Use
1672 the correct pointer type. */
1673 struct type
*pointer_type
1674 = lookup_pointer_type (value_type (last_examine_value
));
1675 set_internalvar (lookup_internalvar ("_"),
1676 value_from_pointer (pointer_type
,
1677 last_examine_address
));
1679 /* Make contents of last address examined available to the user
1680 as $__. If the last value has not been fetched from memory
1681 then don't fetch it now; instead mark it by voiding the $__
1683 if (value_lazy (last_examine_value
))
1684 clear_internalvar (lookup_internalvar ("__"));
1686 set_internalvar (lookup_internalvar ("__"), last_examine_value
);
1691 /* Add an expression to the auto-display chain.
1692 Specify the expression. */
1695 display_command (char *arg
, int from_tty
)
1697 struct format_data fmt
;
1698 struct display
*newobj
;
1699 const char *exp
= arg
;
1710 fmt
= decode_format (&exp
, 0, 0);
1711 if (fmt
.size
&& fmt
.format
== 0)
1713 if (fmt
.format
== 'i' || fmt
.format
== 's')
1724 innermost_block
= NULL
;
1725 expression_up expr
= parse_expression (exp
);
1727 newobj
= new display ();
1729 newobj
->exp_string
= xstrdup (exp
);
1730 newobj
->exp
= std::move (expr
);
1731 newobj
->block
= innermost_block
;
1732 newobj
->pspace
= current_program_space
;
1733 newobj
->number
= ++display_number
;
1734 newobj
->format
= fmt
;
1735 newobj
->enabled_p
= 1;
1736 newobj
->next
= NULL
;
1738 if (display_chain
== NULL
)
1739 display_chain
= newobj
;
1742 struct display
*last
;
1744 for (last
= display_chain
; last
->next
!= NULL
; last
= last
->next
)
1746 last
->next
= newobj
;
1750 do_one_display (newobj
);
1756 free_display (struct display
*d
)
1758 xfree (d
->exp_string
);
1762 /* Clear out the display_chain. Done when new symtabs are loaded,
1763 since this invalidates the types stored in many expressions. */
1766 clear_displays (void)
1770 while ((d
= display_chain
) != NULL
)
1772 display_chain
= d
->next
;
1777 /* Delete the auto-display DISPLAY. */
1780 delete_display (struct display
*display
)
1784 gdb_assert (display
!= NULL
);
1786 if (display_chain
== display
)
1787 display_chain
= display
->next
;
1790 if (d
->next
== display
)
1792 d
->next
= display
->next
;
1796 free_display (display
);
1799 /* Call FUNCTION on each of the displays whose numbers are given in
1800 ARGS. DATA is passed unmodified to FUNCTION. */
1803 map_display_numbers (const char *args
,
1804 void (*function
) (struct display
*,
1811 error_no_arg (_("one or more display numbers"));
1813 number_or_range_parser
parser (args
);
1815 while (!parser
.finished ())
1817 const char *p
= parser
.cur_tok ();
1819 num
= parser
.get_number ();
1821 warning (_("bad display number at or near '%s'"), p
);
1824 struct display
*d
, *tmp
;
1826 ALL_DISPLAYS_SAFE (d
, tmp
)
1827 if (d
->number
== num
)
1830 printf_unfiltered (_("No display number %d.\n"), num
);
1837 /* Callback for map_display_numbers, that deletes a display. */
1840 do_delete_display (struct display
*d
, void *data
)
1845 /* "undisplay" command. */
1848 undisplay_command (const char *args
, int from_tty
)
1852 if (query (_("Delete all auto-display expressions? ")))
1858 map_display_numbers (args
, do_delete_display
, NULL
);
1862 /* Display a single auto-display.
1863 Do nothing if the display cannot be printed in the current context,
1864 or if the display is disabled. */
1867 do_one_display (struct display
*d
)
1869 int within_current_scope
;
1871 if (d
->enabled_p
== 0)
1874 /* The expression carries the architecture that was used at parse time.
1875 This is a problem if the expression depends on architecture features
1876 (e.g. register numbers), and the current architecture is now different.
1877 For example, a display statement like "display/i $pc" is expected to
1878 display the PC register of the current architecture, not the arch at
1879 the time the display command was given. Therefore, we re-parse the
1880 expression if the current architecture has changed. */
1881 if (d
->exp
!= NULL
&& d
->exp
->gdbarch
!= get_current_arch ())
1892 innermost_block
= NULL
;
1893 d
->exp
= parse_expression (d
->exp_string
);
1894 d
->block
= innermost_block
;
1896 CATCH (ex
, RETURN_MASK_ALL
)
1898 /* Can't re-parse the expression. Disable this display item. */
1900 warning (_("Unable to display \"%s\": %s"),
1901 d
->exp_string
, ex
.message
);
1909 if (d
->pspace
== current_program_space
)
1910 within_current_scope
= contained_in (get_selected_block (0), d
->block
);
1912 within_current_scope
= 0;
1915 within_current_scope
= 1;
1916 if (!within_current_scope
)
1919 scoped_restore save_display_number
1920 = make_scoped_restore (¤t_display_number
, d
->number
);
1922 annotate_display_begin ();
1923 printf_filtered ("%d", d
->number
);
1924 annotate_display_number_end ();
1925 printf_filtered (": ");
1929 annotate_display_format ();
1931 printf_filtered ("x/");
1932 if (d
->format
.count
!= 1)
1933 printf_filtered ("%d", d
->format
.count
);
1934 printf_filtered ("%c", d
->format
.format
);
1935 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1936 printf_filtered ("%c", d
->format
.size
);
1937 printf_filtered (" ");
1939 annotate_display_expression ();
1941 puts_filtered (d
->exp_string
);
1942 annotate_display_expression_end ();
1944 if (d
->format
.count
!= 1 || d
->format
.format
== 'i')
1945 printf_filtered ("\n");
1947 printf_filtered (" ");
1949 annotate_display_value ();
1956 val
= evaluate_expression (d
->exp
.get ());
1957 addr
= value_as_address (val
);
1958 if (d
->format
.format
== 'i')
1959 addr
= gdbarch_addr_bits_remove (d
->exp
->gdbarch
, addr
);
1960 do_examine (d
->format
, d
->exp
->gdbarch
, addr
);
1962 CATCH (ex
, RETURN_MASK_ERROR
)
1964 fprintf_filtered (gdb_stdout
, _("<error: %s>\n"), ex
.message
);
1970 struct value_print_options opts
;
1972 annotate_display_format ();
1974 if (d
->format
.format
)
1975 printf_filtered ("/%c ", d
->format
.format
);
1977 annotate_display_expression ();
1979 puts_filtered (d
->exp_string
);
1980 annotate_display_expression_end ();
1982 printf_filtered (" = ");
1984 annotate_display_expression ();
1986 get_formatted_print_options (&opts
, d
->format
.format
);
1987 opts
.raw
= d
->format
.raw
;
1993 val
= evaluate_expression (d
->exp
.get ());
1994 print_formatted (val
, d
->format
.size
, &opts
, gdb_stdout
);
1996 CATCH (ex
, RETURN_MASK_ERROR
)
1998 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
2002 printf_filtered ("\n");
2005 annotate_display_end ();
2007 gdb_flush (gdb_stdout
);
2010 /* Display all of the values on the auto-display chain which can be
2011 evaluated in the current scope. */
2018 for (d
= display_chain
; d
; d
= d
->next
)
2022 /* Delete the auto-display which we were in the process of displaying.
2023 This is done when there is an error or a signal. */
2026 disable_display (int num
)
2030 for (d
= display_chain
; d
; d
= d
->next
)
2031 if (d
->number
== num
)
2036 printf_unfiltered (_("No display number %d.\n"), num
);
2040 disable_current_display (void)
2042 if (current_display_number
>= 0)
2044 disable_display (current_display_number
);
2045 fprintf_unfiltered (gdb_stderr
,
2046 _("Disabling display %d to "
2047 "avoid infinite recursion.\n"),
2048 current_display_number
);
2050 current_display_number
= -1;
2054 info_display_command (char *ignore
, int from_tty
)
2059 printf_unfiltered (_("There are no auto-display expressions now.\n"));
2061 printf_filtered (_("Auto-display expressions now in effect:\n\
2062 Num Enb Expression\n"));
2064 for (d
= display_chain
; d
; d
= d
->next
)
2066 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
2068 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
2070 else if (d
->format
.format
)
2071 printf_filtered ("/%c ", d
->format
.format
);
2072 puts_filtered (d
->exp_string
);
2073 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
))
2074 printf_filtered (_(" (cannot be evaluated in the current context)"));
2075 printf_filtered ("\n");
2076 gdb_flush (gdb_stdout
);
2080 /* Callback fo map_display_numbers, that enables or disables the
2081 passed in display D. */
2084 do_enable_disable_display (struct display
*d
, void *data
)
2086 d
->enabled_p
= *(int *) data
;
2089 /* Implamentation of both the "disable display" and "enable display"
2090 commands. ENABLE decides what to do. */
2093 enable_disable_display_command (const char *args
, int from_tty
, int enable
)
2100 d
->enabled_p
= enable
;
2104 map_display_numbers (args
, do_enable_disable_display
, &enable
);
2107 /* The "enable display" command. */
2110 enable_display_command (const char *args
, int from_tty
)
2112 enable_disable_display_command (args
, from_tty
, 1);
2115 /* The "disable display" command. */
2118 disable_display_command (const char *args
, int from_tty
)
2120 enable_disable_display_command (args
, from_tty
, 0);
2123 /* display_chain items point to blocks and expressions. Some expressions in
2124 turn may point to symbols.
2125 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
2126 obstack_free'd when a shared library is unloaded.
2127 Clear pointers that are about to become dangling.
2128 Both .exp and .block fields will be restored next time we need to display
2129 an item by re-parsing .exp_string field in the new execution context. */
2132 clear_dangling_display_expressions (struct objfile
*objfile
)
2135 struct program_space
*pspace
;
2137 /* With no symbol file we cannot have a block or expression from it. */
2138 if (objfile
== NULL
)
2140 pspace
= objfile
->pspace
;
2141 if (objfile
->separate_debug_objfile_backlink
)
2143 objfile
= objfile
->separate_debug_objfile_backlink
;
2144 gdb_assert (objfile
->pspace
== pspace
);
2147 for (d
= display_chain
; d
!= NULL
; d
= d
->next
)
2149 if (d
->pspace
!= pspace
)
2152 if (lookup_objfile_from_block (d
->block
) == objfile
2153 || (d
->exp
!= NULL
&& exp_uses_objfile (d
->exp
.get (), objfile
)))
2162 /* Print the value in stack frame FRAME of a variable specified by a
2163 struct symbol. NAME is the name to print; if NULL then VAR's print
2164 name will be used. STREAM is the ui_file on which to print the
2165 value. INDENT specifies the number of indent levels to print
2166 before printing the variable name.
2168 This function invalidates FRAME. */
2171 print_variable_and_value (const char *name
, struct symbol
*var
,
2172 struct frame_info
*frame
,
2173 struct ui_file
*stream
, int indent
)
2177 name
= SYMBOL_PRINT_NAME (var
);
2179 fprintf_filtered (stream
, "%s%s = ", n_spaces (2 * indent
), name
);
2183 struct value_print_options opts
;
2185 /* READ_VAR_VALUE needs a block in order to deal with non-local
2186 references (i.e. to handle nested functions). In this context, we
2187 print variables that are local to this frame, so we can avoid passing
2189 val
= read_var_value (var
, NULL
, frame
);
2190 get_user_print_options (&opts
);
2192 common_val_print (val
, stream
, indent
, &opts
, current_language
);
2194 /* common_val_print invalidates FRAME when a pretty printer calls inferior
2198 CATCH (except
, RETURN_MASK_ERROR
)
2200 fprintf_filtered(stream
, "<error reading variable %s (%s)>", name
,
2205 fprintf_filtered (stream
, "\n");
2208 /* Subroutine of ui_printf to simplify it.
2209 Print VALUE to STREAM using FORMAT.
2210 VALUE is a C-style string on the target. */
2213 printf_c_string (struct ui_file
*stream
, const char *format
,
2214 struct value
*value
)
2220 tem
= value_as_address (value
);
2222 /* This is a %s argument. Find the length of the string. */
2228 read_memory (tem
+ j
, &c
, 1);
2233 /* Copy the string contents into a string inside GDB. */
2234 str
= (gdb_byte
*) alloca (j
+ 1);
2236 read_memory (tem
, str
, j
);
2239 fprintf_filtered (stream
, format
, (char *) str
);
2242 /* Subroutine of ui_printf to simplify it.
2243 Print VALUE to STREAM using FORMAT.
2244 VALUE is a wide C-style string on the target. */
2247 printf_wide_c_string (struct ui_file
*stream
, const char *format
,
2248 struct value
*value
)
2253 struct gdbarch
*gdbarch
= get_type_arch (value_type (value
));
2254 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2255 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2256 "wchar_t", NULL
, 0);
2257 int wcwidth
= TYPE_LENGTH (wctype
);
2258 gdb_byte
*buf
= (gdb_byte
*) alloca (wcwidth
);
2260 tem
= value_as_address (value
);
2262 /* This is a %s argument. Find the length of the string. */
2263 for (j
= 0;; j
+= wcwidth
)
2266 read_memory (tem
+ j
, buf
, wcwidth
);
2267 if (extract_unsigned_integer (buf
, wcwidth
, byte_order
) == 0)
2271 /* Copy the string contents into a string inside GDB. */
2272 str
= (gdb_byte
*) alloca (j
+ wcwidth
);
2274 read_memory (tem
, str
, j
);
2275 memset (&str
[j
], 0, wcwidth
);
2277 auto_obstack output
;
2279 convert_between_encodings (target_wide_charset (gdbarch
),
2282 &output
, translit_char
);
2283 obstack_grow_str0 (&output
, "");
2285 fprintf_filtered (stream
, format
, obstack_base (&output
));
2288 /* Subroutine of ui_printf to simplify it.
2289 Print VALUE, a decimal floating point value, to STREAM using FORMAT. */
2292 printf_decfloat (struct ui_file
*stream
, const char *format
,
2293 struct value
*value
)
2295 const gdb_byte
*param_ptr
= value_contents (value
);
2297 #if defined (PRINTF_HAS_DECFLOAT)
2298 /* If we have native support for Decimal floating
2299 printing, handle it here. */
2300 fprintf_filtered (stream
, format
, param_ptr
);
2302 /* As a workaround until vasprintf has native support for DFP
2303 we convert the DFP values to string and print them using
2304 the %s format specifier. */
2307 /* Parameter data. */
2308 struct type
*param_type
= value_type (value
);
2309 struct gdbarch
*gdbarch
= get_type_arch (param_type
);
2310 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2312 /* DFP output data. */
2313 struct value
*dfp_value
= NULL
;
2317 struct type
*dfp_type
= NULL
;
2319 /* Points to the end of the string so that we can go back
2320 and check for DFP length modifiers. */
2321 p
= format
+ strlen (format
);
2323 /* Look for the float/double format specifier. */
2324 while (*p
!= 'f' && *p
!= 'e' && *p
!= 'E'
2325 && *p
!= 'g' && *p
!= 'G')
2328 /* Search for the '%' char and extract the size and type of
2329 the output decimal value based on its modifiers
2330 (%Hf, %Df, %DDf). */
2336 dfp_type
= builtin_type (gdbarch
)->builtin_decfloat
;
2338 else if (*p
== 'D' && *(p
- 1) == 'D')
2341 dfp_type
= builtin_type (gdbarch
)->builtin_declong
;
2347 dfp_type
= builtin_type (gdbarch
)->builtin_decdouble
;
2351 /* Conversion between different DFP types. */
2352 if (TYPE_CODE (param_type
) == TYPE_CODE_DECFLOAT
)
2353 decimal_convert (param_ptr
, TYPE_LENGTH (param_type
),
2354 byte_order
, dec
, dfp_len
, byte_order
);
2356 /* If this is a non-trivial conversion, just output 0.
2357 A correct converted value can be displayed by explicitly
2358 casting to a DFP type. */
2359 decimal_from_string (dec
, dfp_len
, byte_order
, "0");
2361 dfp_value
= value_from_decfloat (dfp_type
, dec
);
2363 dfp_ptr
= (gdb_byte
*) value_contents (dfp_value
);
2365 /* Convert the value to a string and print it. */
2366 std::string str
= decimal_to_string (dfp_ptr
, dfp_len
, byte_order
);
2367 fputs_filtered (str
.c_str (), stream
);
2371 /* Subroutine of ui_printf to simplify it.
2372 Print VALUE, a target pointer, to STREAM using FORMAT. */
2375 printf_pointer (struct ui_file
*stream
, const char *format
,
2376 struct value
*value
)
2378 /* We avoid the host's %p because pointers are too
2379 likely to be the wrong size. The only interesting
2380 modifier for %p is a width; extract that, and then
2381 handle %p as glibc would: %#x or a literal "(nil)". */
2385 #ifdef PRINTF_HAS_LONG_LONG
2386 long long val
= value_as_long (value
);
2388 long val
= value_as_long (value
);
2391 fmt
= (char *) alloca (strlen (format
) + 5);
2393 /* Copy up to the leading %. */
2398 int is_percent
= (*p
== '%');
2413 /* Copy any width. */
2414 while (*p
>= '0' && *p
< '9')
2417 gdb_assert (*p
== 'p' && *(p
+ 1) == '\0');
2420 #ifdef PRINTF_HAS_LONG_LONG
2426 fprintf_filtered (stream
, fmt
, val
);
2432 fprintf_filtered (stream
, fmt
, "(nil)");
2436 /* printf "printf format string" ARG to STREAM. */
2439 ui_printf (const char *arg
, struct ui_file
*stream
)
2441 struct format_piece
*fpieces
;
2442 const char *s
= arg
;
2443 struct value
**val_args
;
2444 int allocated_args
= 20;
2445 struct cleanup
*old_cleanups
;
2447 val_args
= XNEWVEC (struct value
*, allocated_args
);
2448 old_cleanups
= make_cleanup (free_current_contents
, &val_args
);
2451 error_no_arg (_("format-control string and values to print"));
2453 s
= skip_spaces (s
);
2455 /* A format string should follow, enveloped in double quotes. */
2457 error (_("Bad format string, missing '\"'."));
2459 fpieces
= parse_format_string (&s
);
2461 make_cleanup (free_format_pieces_cleanup
, &fpieces
);
2464 error (_("Bad format string, non-terminated '\"'."));
2466 s
= skip_spaces (s
);
2468 if (*s
!= ',' && *s
!= 0)
2469 error (_("Invalid argument syntax"));
2473 s
= skip_spaces (s
);
2479 char *current_substring
;
2482 for (fr
= 0; fpieces
[fr
].string
!= NULL
; fr
++)
2483 if (fpieces
[fr
].argclass
!= literal_piece
)
2486 /* Now, parse all arguments and evaluate them.
2487 Store the VALUEs in VAL_ARGS. */
2493 if (nargs
== allocated_args
)
2494 val_args
= (struct value
**) xrealloc ((char *) val_args
,
2495 (allocated_args
*= 2)
2496 * sizeof (struct value
*));
2498 val_args
[nargs
] = parse_to_comma_and_eval (&s1
);
2506 if (nargs
!= nargs_wanted
)
2507 error (_("Wrong number of arguments for specified format-string"));
2509 /* Now actually print them. */
2511 for (fr
= 0; fpieces
[fr
].string
!= NULL
; fr
++)
2513 current_substring
= fpieces
[fr
].string
;
2514 switch (fpieces
[fr
].argclass
)
2517 printf_c_string (stream
, current_substring
, val_args
[i
]);
2519 case wide_string_arg
:
2520 printf_wide_c_string (stream
, current_substring
, val_args
[i
]);
2524 struct gdbarch
*gdbarch
2525 = get_type_arch (value_type (val_args
[i
]));
2526 struct type
*wctype
= lookup_typename (current_language
, gdbarch
,
2527 "wchar_t", NULL
, 0);
2528 struct type
*valtype
;
2529 const gdb_byte
*bytes
;
2531 valtype
= value_type (val_args
[i
]);
2532 if (TYPE_LENGTH (valtype
) != TYPE_LENGTH (wctype
)
2533 || TYPE_CODE (valtype
) != TYPE_CODE_INT
)
2534 error (_("expected wchar_t argument for %%lc"));
2536 bytes
= value_contents (val_args
[i
]);
2538 auto_obstack output
;
2540 convert_between_encodings (target_wide_charset (gdbarch
),
2542 bytes
, TYPE_LENGTH (valtype
),
2543 TYPE_LENGTH (valtype
),
2544 &output
, translit_char
);
2545 obstack_grow_str0 (&output
, "");
2547 fprintf_filtered (stream
, current_substring
,
2548 obstack_base (&output
));
2553 struct type
*type
= value_type (val_args
[i
]);
2557 /* If format string wants a float, unchecked-convert the value
2558 to floating point of the same size. */
2559 type
= float_type_from_length (type
);
2560 val
= unpack_double (type
, value_contents (val_args
[i
]), &inv
);
2562 error (_("Invalid floating value found in program."));
2564 fprintf_filtered (stream
, current_substring
, (double) val
);
2567 case long_double_arg
:
2568 #ifdef HAVE_LONG_DOUBLE
2570 struct type
*type
= value_type (val_args
[i
]);
2574 /* If format string wants a float, unchecked-convert the value
2575 to floating point of the same size. */
2576 type
= float_type_from_length (type
);
2577 val
= unpack_double (type
, value_contents (val_args
[i
]), &inv
);
2579 error (_("Invalid floating value found in program."));
2581 fprintf_filtered (stream
, current_substring
,
2586 error (_("long double not supported in printf"));
2589 #ifdef PRINTF_HAS_LONG_LONG
2591 long long val
= value_as_long (val_args
[i
]);
2593 fprintf_filtered (stream
, current_substring
, val
);
2597 error (_("long long not supported in printf"));
2601 int val
= value_as_long (val_args
[i
]);
2603 fprintf_filtered (stream
, current_substring
, val
);
2608 long val
= value_as_long (val_args
[i
]);
2610 fprintf_filtered (stream
, current_substring
, val
);
2613 /* Handles decimal floating values. */
2615 printf_decfloat (stream
, current_substring
, val_args
[i
]);
2618 printf_pointer (stream
, current_substring
, val_args
[i
]);
2621 /* Print a portion of the format string that has no
2622 directives. Note that this will not include any
2623 ordinary %-specs, but it might include "%%". That is
2624 why we use printf_filtered and not puts_filtered here.
2625 Also, we pass a dummy argument because some platforms
2626 have modified GCC to include -Wformat-security by
2627 default, which will warn here if there is no
2629 fprintf_filtered (stream
, current_substring
, 0);
2632 internal_error (__FILE__
, __LINE__
,
2633 _("failed internal consistency check"));
2635 /* Maybe advance to the next argument. */
2636 if (fpieces
[fr
].argclass
!= literal_piece
)
2640 do_cleanups (old_cleanups
);
2643 /* Implement the "printf" command. */
2646 printf_command (char *arg
, int from_tty
)
2648 ui_printf (arg
, gdb_stdout
);
2649 gdb_flush (gdb_stdout
);
2652 /* Implement the "eval" command. */
2655 eval_command (char *arg
, int from_tty
)
2659 ui_printf (arg
, &stb
);
2661 std::string expanded
= insert_user_defined_cmd_args (stb
.c_str ());
2663 execute_command (&expanded
[0], from_tty
);
2667 _initialize_printcmd (void)
2669 struct cmd_list_element
*c
;
2671 current_display_number
= -1;
2673 observer_attach_free_objfile (clear_dangling_display_expressions
);
2675 add_info ("address", info_address_command
,
2676 _("Describe where symbol SYM is stored."));
2678 add_info ("symbol", info_symbol_command
, _("\
2679 Describe what symbol is at location ADDR.\n\
2680 Only for symbols with fixed locations (global or static scope)."));
2682 add_com ("x", class_vars
, x_command
, _("\
2683 Examine memory: x/FMT ADDRESS.\n\
2684 ADDRESS is an expression for the memory address to examine.\n\
2685 FMT is a repeat count followed by a format letter and a size letter.\n\
2686 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2687 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2688 and z(hex, zero padded on the left).\n\
2689 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2690 The specified number of objects of the specified size are printed\n\
2691 according to the format. If a negative number is specified, memory is\n\
2692 examined backward from the address.\n\n\
2693 Defaults for format and size letters are those previously used.\n\
2694 Default count is 1. Default address is following last thing printed\n\
2695 with this command or \"print\"."));
2698 add_com ("whereis", class_vars
, whereis_command
,
2699 _("Print line number and file of definition of variable."));
2702 add_info ("display", info_display_command
, _("\
2703 Expressions to display when program stops, with code numbers."));
2705 add_cmd ("undisplay", class_vars
, undisplay_command
, _("\
2706 Cancel some expressions to be displayed when program stops.\n\
2707 Arguments are the code numbers of the expressions to stop displaying.\n\
2708 No argument means cancel all automatic-display expressions.\n\
2709 \"delete display\" has the same effect as this command.\n\
2710 Do \"info display\" to see current list of code numbers."),
2713 add_com ("display", class_vars
, display_command
, _("\
2714 Print value of expression EXP each time the program stops.\n\
2715 /FMT may be used before EXP as in the \"print\" command.\n\
2716 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2717 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2718 and examining is done as in the \"x\" command.\n\n\
2719 With no argument, display all currently requested auto-display expressions.\n\
2720 Use \"undisplay\" to cancel display requests previously made."));
2722 add_cmd ("display", class_vars
, enable_display_command
, _("\
2723 Enable some expressions to be displayed when program stops.\n\
2724 Arguments are the code numbers of the expressions to resume displaying.\n\
2725 No argument means enable all automatic-display expressions.\n\
2726 Do \"info display\" to see current list of code numbers."), &enablelist
);
2728 add_cmd ("display", class_vars
, disable_display_command
, _("\
2729 Disable some expressions to be displayed when program stops.\n\
2730 Arguments are the code numbers of the expressions to stop displaying.\n\
2731 No argument means disable all automatic-display expressions.\n\
2732 Do \"info display\" to see current list of code numbers."), &disablelist
);
2734 add_cmd ("display", class_vars
, undisplay_command
, _("\
2735 Cancel some expressions to be displayed when program stops.\n\
2736 Arguments are the code numbers of the expressions to stop displaying.\n\
2737 No argument means cancel all automatic-display expressions.\n\
2738 Do \"info display\" to see current list of code numbers."), &deletelist
);
2740 add_com ("printf", class_vars
, printf_command
, _("\
2741 printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2742 This is useful for formatted output in user-defined commands."));
2744 add_com ("output", class_vars
, output_command
, _("\
2745 Like \"print\" but don't put in value history and don't print newline.\n\
2746 This is useful in user-defined commands."));
2748 add_prefix_cmd ("set", class_vars
, set_command
, _("\
2749 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2750 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2751 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2752 with $), a register (a few standard names starting with $), or an actual\n\
2753 variable in the program being debugged. EXP is any valid expression.\n\
2754 Use \"set variable\" for variables with names identical to set subcommands.\n\
2756 With a subcommand, this command modifies parts of the gdb environment.\n\
2757 You can see these environment settings with the \"show\" command."),
2758 &setlist
, "set ", 1, &cmdlist
);
2760 add_com ("assign", class_vars
, non_const_set_command
, _("\
2761 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2762 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2763 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2764 with $), a register (a few standard names starting with $), or an actual\n\
2765 variable in the program being debugged. EXP is any valid expression.\n\
2766 Use \"set variable\" for variables with names identical to set subcommands.\n\
2767 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2768 You can see these environment settings with the \"show\" command."));
2770 /* "call" is the same as "set", but handy for dbx users to call fns. */
2771 c
= add_com ("call", class_vars
, call_command
, _("\
2772 Call a function in the program.\n\
2773 The argument is the function name and arguments, in the notation of the\n\
2774 current working language. The result is printed and saved in the value\n\
2775 history, if it is not void."));
2776 set_cmd_completer (c
, expression_completer
);
2778 add_cmd ("variable", class_vars
, set_command
, _("\
2779 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2780 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2781 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2782 with $), a register (a few standard names starting with $), or an actual\n\
2783 variable in the program being debugged. EXP is any valid expression.\n\
2784 This may usually be abbreviated to simply \"set\"."),
2787 c
= add_com ("print", class_vars
, print_command
, _("\
2788 Print value of expression EXP.\n\
2789 Variables accessible are those of the lexical environment of the selected\n\
2790 stack frame, plus all those whose scope is global or an entire file.\n\
2792 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2793 $$NUM refers to NUM'th value back from the last one.\n\
2794 Names starting with $ refer to registers (with the values they would have\n\
2795 if the program were to return to the stack frame now selected, restoring\n\
2796 all registers saved by frames farther in) or else to debugger\n\
2797 \"convenience\" variables (any such name not a known register).\n\
2798 Use assignment expressions to give values to convenience variables.\n\
2800 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2801 @ is a binary operator for treating consecutive data objects\n\
2802 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2803 element is FOO, whose second element is stored in the space following\n\
2804 where FOO is stored, etc. FOO must be an expression whose value\n\
2805 resides in memory.\n\
2807 EXP may be preceded with /FMT, where FMT is a format letter\n\
2808 but no count or size letter (see \"x\" command)."));
2809 set_cmd_completer (c
, expression_completer
);
2810 add_com_alias ("p", "print", class_vars
, 1);
2811 add_com_alias ("inspect", "print", class_vars
, 1);
2813 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class
,
2814 &max_symbolic_offset
, _("\
2815 Set the largest offset that will be printed in <symbol+1234> form."), _("\
2816 Show the largest offset that will be printed in <symbol+1234> form."), _("\
2817 Tell GDB to only display the symbolic form of an address if the\n\
2818 offset between the closest earlier symbol and the address is less than\n\
2819 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
2820 to always print the symbolic form of an address if any symbol precedes\n\
2821 it. Zero is equivalent to \"unlimited\"."),
2823 show_max_symbolic_offset
,
2824 &setprintlist
, &showprintlist
);
2825 add_setshow_boolean_cmd ("symbol-filename", no_class
,
2826 &print_symbol_filename
, _("\
2827 Set printing of source filename and line number with <symbol>."), _("\
2828 Show printing of source filename and line number with <symbol>."), NULL
,
2830 show_print_symbol_filename
,
2831 &setprintlist
, &showprintlist
);
2833 add_com ("eval", no_class
, eval_command
, _("\
2834 Convert \"printf format string\", arg1, arg2, arg3, ..., argn to\n\
2835 a command line, and call it."));