1 /* Print values for GNU debugger GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
25 #include "gdb_string.h"
31 #include "expression.h"
35 #include "breakpoint.h"
39 #include "symfile.h" /* for overlay functions */
40 #include "objfiles.h" /* ditto */
41 #include "completer.h" /* for completion functions */
43 #include "gdb_assert.h"
48 #include "tui/tui.h" /* For tui_active et.al. */
51 extern int asm_demangle
; /* Whether to demangle syms in asm printouts */
52 extern int addressprint
; /* Whether to print hex addresses in HLL " */
61 /* Last specified output format. */
63 static char last_format
= 'x';
65 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
67 static char last_size
= 'w';
69 /* Default address to examine next. */
71 static CORE_ADDR next_address
;
73 /* Number of delay instructions following current disassembled insn. */
75 static int branch_delay_insns
;
77 /* Last address examined. */
79 static CORE_ADDR last_examine_address
;
81 /* Contents of last address examined.
82 This is not valid past the end of the `x' command! */
84 static struct value
*last_examine_value
;
86 /* Largest offset between a symbolic value and an address, that will be
87 printed as `0x1234 <symbol+offset>'. */
89 static unsigned int max_symbolic_offset
= UINT_MAX
;
91 show_max_symbolic_offset (struct ui_file
*file
, int from_tty
,
92 struct cmd_list_element
*c
, const char *value
)
94 fprintf_filtered (file
, _("\
95 The largest offset that will be printed in <symbol+1234> form is %s.\n"),
99 /* Append the source filename and linenumber of the symbol when
100 printing a symbolic value as `<symbol at filename:linenum>' if set. */
101 static int print_symbol_filename
= 0;
103 show_print_symbol_filename (struct ui_file
*file
, int from_tty
,
104 struct cmd_list_element
*c
, const char *value
)
106 fprintf_filtered (file
, _("\
107 Printing of source filename and line number with <symbol> is %s.\n"),
111 /* Number of auto-display expression currently being displayed.
112 So that we can disable it if we get an error or a signal within it.
113 -1 when not doing one. */
115 int current_display_number
;
117 /* Flag to low-level print routines that this value is being printed
118 in an epoch window. We'd like to pass this as a parameter, but
119 every routine would need to take it. Perhaps we can encapsulate
120 this in the I/O stream once we have GNU stdio. */
126 /* Chain link to next auto-display item. */
127 struct display
*next
;
128 /* Expression to be evaluated and displayed. */
129 struct expression
*exp
;
130 /* Item number of this auto-display item. */
132 /* Display format specified. */
133 struct format_data format
;
134 /* Innermost block required by this expression when evaluated */
136 /* Status of this display (enabled or disabled) */
140 /* Chain of expressions whose values should be displayed
141 automatically each time the program stops. */
143 static struct display
*display_chain
;
145 static int display_number
;
147 /* Prototypes for exported functions. */
149 void output_command (char *, int);
151 void _initialize_printcmd (void);
153 /* Prototypes for local functions. */
155 static void do_one_display (struct display
*);
158 /* Decode a format specification. *STRING_PTR should point to it.
159 OFORMAT and OSIZE are used as defaults for the format and size
160 if none are given in the format specification.
161 If OSIZE is zero, then the size field of the returned value
162 should be set only if a size is explicitly specified by the
164 The structure returned describes all the data
165 found in the specification. In addition, *STRING_PTR is advanced
166 past the specification and past all whitespace following it. */
168 static struct format_data
169 decode_format (char **string_ptr
, int oformat
, int osize
)
171 struct format_data val
;
172 char *p
= *string_ptr
;
178 if (*p
>= '0' && *p
<= '9')
179 val
.count
= atoi (p
);
180 while (*p
>= '0' && *p
<= '9')
183 /* Now process size or format letters that follow. */
187 if (*p
== 'b' || *p
== 'h' || *p
== 'w' || *p
== 'g')
189 else if (*p
>= 'a' && *p
<= 'z')
195 while (*p
== ' ' || *p
== '\t')
199 /* Set defaults for format and size if not specified. */
200 if (val
.format
== '?')
204 /* Neither has been specified. */
205 val
.format
= oformat
;
209 /* If a size is specified, any format makes a reasonable
210 default except 'i'. */
211 val
.format
= oformat
== 'i' ? 'x' : oformat
;
213 else if (val
.size
== '?')
218 /* Pick the appropriate size for an address. */
219 if (gdbarch_ptr_bit (current_gdbarch
) == 64)
220 val
.size
= osize
? 'g' : osize
;
221 else if (gdbarch_ptr_bit (current_gdbarch
) == 32)
222 val
.size
= osize
? 'w' : osize
;
223 else if (gdbarch_ptr_bit (current_gdbarch
) == 16)
224 val
.size
= osize
? 'h' : osize
;
226 /* Bad value for gdbarch_ptr_bit. */
227 internal_error (__FILE__
, __LINE__
,
228 _("failed internal consistency check"));
231 /* Floating point has to be word or giantword. */
232 if (osize
== 'w' || osize
== 'g')
235 /* Default it to giantword if the last used size is not
237 val
.size
= osize
? 'g' : osize
;
240 /* Characters default to one byte. */
241 val
.size
= osize
? 'b' : osize
;
244 /* The default is the size most recently specified. */
251 /* Print value VAL on stream according to FORMAT, a letter or 0.
252 Do not end with a newline.
253 0 means print VAL according to its own type.
254 SIZE is the letter for the size of datum being printed.
255 This is used to pad hex numbers so they line up. */
258 print_formatted (struct value
*val
, int format
, int size
,
259 struct ui_file
*stream
)
261 struct type
*type
= check_typedef (value_type (val
));
262 int len
= TYPE_LENGTH (type
);
264 if (VALUE_LVAL (val
) == lval_memory
)
265 next_address
= VALUE_ADDRESS (val
) + len
;
270 /* FIXME: Need to handle wchar_t's here... */
271 next_address
= VALUE_ADDRESS (val
)
272 + val_print_string (VALUE_ADDRESS (val
), -1, 1, stream
);
276 /* The old comment says
277 "Force output out, print_insn not using _filtered".
278 I'm not completely sure what that means, I suspect most print_insn
279 now do use _filtered, so I guess it's obsolete.
280 --Yes, it does filter now, and so this is obsolete. -JB */
282 /* We often wrap here if there are long symbolic names. */
284 next_address
= (VALUE_ADDRESS (val
)
285 + gdb_print_insn (VALUE_ADDRESS (val
), stream
,
286 &branch_delay_insns
));
291 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
292 || TYPE_CODE (type
) == TYPE_CODE_STRING
293 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
294 || TYPE_CODE (type
) == TYPE_CODE_UNION
295 || TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
296 /* If format is 0, use the 'natural' format for that type of
297 value. If the type is non-scalar, we have to use language
298 rules to print it as a series of scalars. */
299 value_print (val
, stream
, format
, Val_pretty_default
);
301 /* User specified format, so don't look to the the type to
302 tell us what to do. */
303 print_scalar_formatted (value_contents (val
), type
,
304 format
, size
, stream
);
308 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
309 according to letters FORMAT and SIZE on STREAM.
310 FORMAT may not be zero. Formats s and i are not supported at this level.
312 This is how the elements of an array or structure are printed
316 print_scalar_formatted (const void *valaddr
, struct type
*type
,
317 int format
, int size
, struct ui_file
*stream
)
319 LONGEST val_long
= 0;
320 unsigned int len
= TYPE_LENGTH (type
);
322 if (len
> sizeof(LONGEST
) &&
323 (TYPE_CODE (type
) == TYPE_CODE_INT
324 || TYPE_CODE (type
) == TYPE_CODE_ENUM
))
329 print_octal_chars (stream
, valaddr
, len
);
333 print_decimal_chars (stream
, valaddr
, len
);
336 print_binary_chars (stream
, valaddr
, len
);
339 print_hex_chars (stream
, valaddr
, len
);
342 print_char_chars (stream
, valaddr
, len
);
350 val_long
= unpack_long (type
, valaddr
);
352 /* If the value is a pointer, and pointers and addresses are not the
353 same, then at this point, the value's length (in target bytes) is
354 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
355 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
356 len
= gdbarch_addr_bit (current_gdbarch
) / TARGET_CHAR_BIT
;
358 /* If we are printing it as unsigned, truncate it in case it is actually
359 a negative signed value (e.g. "print/u (short)-1" should print 65535
360 (if shorts are 16 bits) instead of 4294967295). */
363 if (len
< sizeof (LONGEST
))
364 val_long
&= ((LONGEST
) 1 << HOST_CHAR_BIT
* len
) - 1;
372 /* No size specified, like in print. Print varying # of digits. */
373 print_longest (stream
, 'x', 1, val_long
);
382 print_longest (stream
, size
, 1, val_long
);
385 error (_("Undefined output size \"%c\"."), size
);
390 print_longest (stream
, 'd', 1, val_long
);
394 print_longest (stream
, 'u', 0, val_long
);
399 print_longest (stream
, 'o', 1, val_long
);
401 fprintf_filtered (stream
, "0");
406 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
407 print_address (addr
, stream
);
412 value_print (value_from_longest (builtin_type_true_char
, val_long
),
413 stream
, 0, Val_pretty_default
);
417 if (len
== TYPE_LENGTH (builtin_type_float
))
418 type
= builtin_type_float
;
419 else if (len
== TYPE_LENGTH (builtin_type_double
))
420 type
= builtin_type_double
;
421 else if (len
== TYPE_LENGTH (builtin_type_long_double
))
422 type
= builtin_type_long_double
;
423 print_floating (valaddr
, type
, stream
);
427 internal_error (__FILE__
, __LINE__
,
428 _("failed internal consistency check"));
431 /* Binary; 't' stands for "two". */
433 char bits
[8 * (sizeof val_long
) + 1];
434 char buf
[8 * (sizeof val_long
) + 32];
439 width
= 8 * (sizeof val_long
);
456 error (_("Undefined output size \"%c\"."), size
);
462 bits
[width
] = (val_long
& 1) ? '1' : '0';
467 while (*cp
&& *cp
== '0')
473 fputs_filtered (buf
, stream
);
478 error (_("Undefined output format \"%c\"."), format
);
482 /* Specify default address for `x' command.
483 The `info lines' command uses this. */
486 set_next_address (CORE_ADDR addr
)
490 /* Make address available to the user as $_. */
491 set_internalvar (lookup_internalvar ("_"),
492 value_from_pointer (lookup_pointer_type (builtin_type_void
),
496 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
497 after LEADIN. Print nothing if no symbolic name is found nearby.
498 Optionally also print source file and line number, if available.
499 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
500 or to interpret it as a possible C++ name and convert it back to source
501 form. However note that DO_DEMANGLE can be overridden by the specific
502 settings of the demangle and asm_demangle variables. */
505 print_address_symbolic (CORE_ADDR addr
, struct ui_file
*stream
,
506 int do_demangle
, char *leadin
)
509 char *filename
= NULL
;
514 /* Throw away both name and filename. */
515 struct cleanup
*cleanup_chain
= make_cleanup (free_current_contents
, &name
);
516 make_cleanup (free_current_contents
, &filename
);
518 if (build_address_symbolic (addr
, do_demangle
, &name
, &offset
,
519 &filename
, &line
, &unmapped
))
521 do_cleanups (cleanup_chain
);
525 fputs_filtered (leadin
, stream
);
527 fputs_filtered ("<*", stream
);
529 fputs_filtered ("<", stream
);
530 fputs_filtered (name
, stream
);
532 fprintf_filtered (stream
, "+%u", (unsigned int) offset
);
534 /* Append source filename and line number if desired. Give specific
535 line # of this addr, if we have it; else line # of the nearest symbol. */
536 if (print_symbol_filename
&& filename
!= NULL
)
539 fprintf_filtered (stream
, " at %s:%d", filename
, line
);
541 fprintf_filtered (stream
, " in %s", filename
);
544 fputs_filtered ("*>", stream
);
546 fputs_filtered (">", stream
);
548 do_cleanups (cleanup_chain
);
551 /* Given an address ADDR return all the elements needed to print the
552 address in a symbolic form. NAME can be mangled or not depending
553 on DO_DEMANGLE (and also on the asm_demangle global variable,
554 manipulated via ''set print asm-demangle''). Return 0 in case of
555 success, when all the info in the OUT paramters is valid. Return 1
558 build_address_symbolic (CORE_ADDR addr
, /* IN */
559 int do_demangle
, /* IN */
560 char **name
, /* OUT */
561 int *offset
, /* OUT */
562 char **filename
, /* OUT */
564 int *unmapped
) /* OUT */
566 struct minimal_symbol
*msymbol
;
567 struct symbol
*symbol
;
568 struct symtab
*symtab
= 0;
569 CORE_ADDR name_location
= 0;
570 asection
*section
= 0;
571 char *name_temp
= "";
573 /* Let's say it is unmapped. */
576 /* Determine if the address is in an overlay, and whether it is
578 if (overlay_debugging
)
580 section
= find_pc_overlay (addr
);
581 if (pc_in_unmapped_range (addr
, section
))
584 addr
= overlay_mapped_address (addr
, section
);
588 /* First try to find the address in the symbol table, then
589 in the minsyms. Take the closest one. */
591 /* This is defective in the sense that it only finds text symbols. So
592 really this is kind of pointless--we should make sure that the
593 minimal symbols have everything we need (by changing that we could
594 save some memory, but for many debug format--ELF/DWARF or
595 anything/stabs--it would be inconvenient to eliminate those minimal
597 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
598 symbol
= find_pc_sect_function (addr
, section
);
602 name_location
= BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
));
603 if (do_demangle
|| asm_demangle
)
604 name_temp
= SYMBOL_PRINT_NAME (symbol
);
606 name_temp
= DEPRECATED_SYMBOL_NAME (symbol
);
611 if (SYMBOL_VALUE_ADDRESS (msymbol
) > name_location
|| symbol
== NULL
)
613 /* The msymbol is closer to the address than the symbol;
614 use the msymbol instead. */
617 name_location
= SYMBOL_VALUE_ADDRESS (msymbol
);
618 if (do_demangle
|| asm_demangle
)
619 name_temp
= SYMBOL_PRINT_NAME (msymbol
);
621 name_temp
= DEPRECATED_SYMBOL_NAME (msymbol
);
624 if (symbol
== NULL
&& msymbol
== NULL
)
627 /* If the nearest symbol is too far away, don't print anything symbolic. */
629 /* For when CORE_ADDR is larger than unsigned int, we do math in
630 CORE_ADDR. But when we detect unsigned wraparound in the
631 CORE_ADDR math, we ignore this test and print the offset,
632 because addr+max_symbolic_offset has wrapped through the end
633 of the address space back to the beginning, giving bogus comparison. */
634 if (addr
> name_location
+ max_symbolic_offset
635 && name_location
+ max_symbolic_offset
> name_location
)
638 *offset
= addr
- name_location
;
640 *name
= xstrdup (name_temp
);
642 if (print_symbol_filename
)
644 struct symtab_and_line sal
;
646 sal
= find_pc_sect_line (addr
, section
, 0);
650 *filename
= xstrdup (sal
.symtab
->filename
);
653 else if (symtab
&& symbol
&& symbol
->line
)
655 *filename
= xstrdup (symtab
->filename
);
656 *line
= symbol
->line
;
660 *filename
= xstrdup (symtab
->filename
);
667 /* Print address ADDR on STREAM. USE_LOCAL means the same thing as for
670 deprecated_print_address_numeric (CORE_ADDR addr
, int use_local
,
671 struct ui_file
*stream
)
674 fputs_filtered (paddress (addr
), stream
);
677 int addr_bit
= gdbarch_addr_bit (current_gdbarch
);
679 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
680 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
681 print_longest (stream
, 'x', 0, (ULONGEST
) addr
);
685 /* Print address ADDR symbolically on STREAM.
686 First print it as a number. Then perhaps print
687 <SYMBOL + OFFSET> after the number. */
690 print_address (CORE_ADDR addr
, struct ui_file
*stream
)
692 deprecated_print_address_numeric (addr
, 1, stream
);
693 print_address_symbolic (addr
, stream
, asm_demangle
, " ");
696 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
697 controls whether to print the symbolic name "raw" or demangled.
698 Global setting "addressprint" controls whether to print hex address
702 print_address_demangle (CORE_ADDR addr
, struct ui_file
*stream
,
707 fprintf_filtered (stream
, "0");
709 else if (addressprint
)
711 deprecated_print_address_numeric (addr
, 1, stream
);
712 print_address_symbolic (addr
, stream
, do_demangle
, " ");
716 print_address_symbolic (addr
, stream
, do_demangle
, "");
721 /* These are the types that $__ will get after an examine command of one
724 static struct type
*examine_i_type
;
726 static struct type
*examine_b_type
;
727 static struct type
*examine_h_type
;
728 static struct type
*examine_w_type
;
729 static struct type
*examine_g_type
;
731 /* Examine data at address ADDR in format FMT.
732 Fetch it from memory and print on gdb_stdout. */
735 do_examine (struct format_data fmt
, CORE_ADDR addr
)
740 struct type
*val_type
= NULL
;
749 /* String or instruction format implies fetch single bytes
750 regardless of the specified size. */
751 if (format
== 's' || format
== 'i')
755 val_type
= examine_i_type
;
756 else if (size
== 'b')
757 val_type
= examine_b_type
;
758 else if (size
== 'h')
759 val_type
= examine_h_type
;
760 else if (size
== 'w')
761 val_type
= examine_w_type
;
762 else if (size
== 'g')
763 val_type
= examine_g_type
;
770 if (format
== 's' || format
== 'i')
773 /* Print as many objects as specified in COUNT, at most maxelts per line,
774 with the address of the next one at the start of each line. */
779 print_address (next_address
, gdb_stdout
);
780 printf_filtered (":");
785 printf_filtered ("\t");
786 /* Note that print_formatted sets next_address for the next
788 last_examine_address
= next_address
;
790 if (last_examine_value
)
791 value_free (last_examine_value
);
793 /* The value to be displayed is not fetched greedily.
794 Instead, to avoid the possibility of a fetched value not
795 being used, its retrieval is delayed until the print code
796 uses it. When examining an instruction stream, the
797 disassembler will perform its own memory fetch using just
798 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
799 the disassembler be modified so that LAST_EXAMINE_VALUE
800 is left with the byte sequence from the last complete
801 instruction fetched from memory? */
802 last_examine_value
= value_at_lazy (val_type
, next_address
);
804 if (last_examine_value
)
805 release_value (last_examine_value
);
807 print_formatted (last_examine_value
, format
, size
, gdb_stdout
);
809 /* Display any branch delay slots following the final insn. */
810 if (format
== 'i' && count
== 1)
811 count
+= branch_delay_insns
;
813 printf_filtered ("\n");
814 gdb_flush (gdb_stdout
);
819 validate_format (struct format_data fmt
, char *cmdname
)
822 error (_("Size letters are meaningless in \"%s\" command."), cmdname
);
824 error (_("Item count other than 1 is meaningless in \"%s\" command."),
826 if (fmt
.format
== 'i' || fmt
.format
== 's')
827 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
828 fmt
.format
, cmdname
);
831 /* Evaluate string EXP as an expression in the current language and
832 print the resulting value. EXP may contain a format specifier as the
833 first argument ("/x myvar" for example, to print myvar in hex). */
836 print_command_1 (char *exp
, int inspect
, int voidprint
)
838 struct expression
*expr
;
839 struct cleanup
*old_chain
= 0;
842 struct format_data fmt
;
845 /* Pass inspect flag to the rest of the print routines in a global
847 inspect_it
= inspect
;
849 if (exp
&& *exp
== '/')
852 fmt
= decode_format (&exp
, last_format
, 0);
853 validate_format (fmt
, "print");
854 last_format
= format
= fmt
.format
;
866 expr
= parse_expression (exp
);
867 old_chain
= make_cleanup (free_current_contents
, &expr
);
869 val
= evaluate_expression (expr
);
872 val
= access_value_history (0);
874 if (voidprint
|| (val
&& value_type (val
) &&
875 TYPE_CODE (value_type (val
)) != TYPE_CODE_VOID
))
877 int histindex
= record_latest_value (val
);
880 annotate_value_history_begin (histindex
, value_type (val
));
882 annotate_value_begin (value_type (val
));
885 printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"",
887 else if (histindex
>= 0)
888 printf_filtered ("$%d = ", histindex
);
891 annotate_value_history_value ();
893 print_formatted (val
, format
, fmt
.size
, gdb_stdout
);
894 printf_filtered ("\n");
897 annotate_value_history_end ();
899 annotate_value_end ();
902 printf_unfiltered ("\") )\030");
906 do_cleanups (old_chain
);
907 inspect_it
= 0; /* Reset print routines to normal. */
911 print_command (char *exp
, int from_tty
)
913 print_command_1 (exp
, 0, 1);
916 /* Same as print, except in epoch, it gets its own window. */
918 inspect_command (char *exp
, int from_tty
)
920 extern int epoch_interface
;
922 print_command_1 (exp
, epoch_interface
, 1);
925 /* Same as print, except it doesn't print void results. */
927 call_command (char *exp
, int from_tty
)
929 print_command_1 (exp
, 0, 0);
933 output_command (char *exp
, int from_tty
)
935 struct expression
*expr
;
936 struct cleanup
*old_chain
;
939 struct format_data fmt
;
943 if (exp
&& *exp
== '/')
946 fmt
= decode_format (&exp
, 0, 0);
947 validate_format (fmt
, "output");
951 expr
= parse_expression (exp
);
952 old_chain
= make_cleanup (free_current_contents
, &expr
);
954 val
= evaluate_expression (expr
);
956 annotate_value_begin (value_type (val
));
958 print_formatted (val
, format
, fmt
.size
, gdb_stdout
);
960 annotate_value_end ();
963 gdb_flush (gdb_stdout
);
965 do_cleanups (old_chain
);
969 set_command (char *exp
, int from_tty
)
971 struct expression
*expr
= parse_expression (exp
);
972 struct cleanup
*old_chain
=
973 make_cleanup (free_current_contents
, &expr
);
974 evaluate_expression (expr
);
975 do_cleanups (old_chain
);
979 sym_info (char *arg
, int from_tty
)
981 struct minimal_symbol
*msymbol
;
982 struct objfile
*objfile
;
983 struct obj_section
*osect
;
985 CORE_ADDR addr
, sect_addr
;
990 error_no_arg (_("address"));
992 addr
= parse_and_eval_address (arg
);
993 ALL_OBJSECTIONS (objfile
, osect
)
995 /* Only process each object file once, even if there's a separate
997 if (objfile
->separate_debug_objfile_backlink
)
1000 sect
= osect
->the_bfd_section
;
1001 sect_addr
= overlay_mapped_address (addr
, sect
);
1003 if (osect
->addr
<= sect_addr
&& sect_addr
< osect
->endaddr
&&
1004 (msymbol
= lookup_minimal_symbol_by_pc_section (sect_addr
, sect
)))
1007 offset
= sect_addr
- SYMBOL_VALUE_ADDRESS (msymbol
);
1009 printf_filtered ("%s + %u in ",
1010 SYMBOL_PRINT_NAME (msymbol
), offset
);
1012 printf_filtered ("%s in ",
1013 SYMBOL_PRINT_NAME (msymbol
));
1014 if (pc_in_unmapped_range (addr
, sect
))
1015 printf_filtered (_("load address range of "));
1016 if (section_is_overlay (sect
))
1017 printf_filtered (_("%s overlay "),
1018 section_is_mapped (sect
) ? "mapped" : "unmapped");
1019 printf_filtered (_("section %s"), sect
->name
);
1020 printf_filtered ("\n");
1024 printf_filtered (_("No symbol matches %s.\n"), arg
);
1028 address_info (char *exp
, int from_tty
)
1031 struct minimal_symbol
*msymbol
;
1035 CORE_ADDR load_addr
;
1036 int is_a_field_of_this
; /* C++: lookup_symbol sets this to nonzero
1037 if exp is a field of `this'. */
1040 error (_("Argument required."));
1042 sym
= lookup_symbol (exp
, get_selected_block (0), VAR_DOMAIN
,
1043 &is_a_field_of_this
, (struct symtab
**) NULL
);
1046 if (is_a_field_of_this
)
1048 printf_filtered ("Symbol \"");
1049 fprintf_symbol_filtered (gdb_stdout
, exp
,
1050 current_language
->la_language
, DMGL_ANSI
);
1051 printf_filtered ("\" is a field of the local class variable ");
1052 if (current_language
->la_language
== language_objc
)
1053 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1055 printf_filtered ("`this'\n");
1059 msymbol
= lookup_minimal_symbol (exp
, NULL
, NULL
);
1061 if (msymbol
!= NULL
)
1063 load_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1065 printf_filtered ("Symbol \"");
1066 fprintf_symbol_filtered (gdb_stdout
, exp
,
1067 current_language
->la_language
, DMGL_ANSI
);
1068 printf_filtered ("\" is at ");
1069 deprecated_print_address_numeric (load_addr
, 1, gdb_stdout
);
1070 printf_filtered (" in a file compiled without debugging");
1071 section
= SYMBOL_BFD_SECTION (msymbol
);
1072 if (section_is_overlay (section
))
1074 load_addr
= overlay_unmapped_address (load_addr
, section
);
1075 printf_filtered (",\n -- loaded at ");
1076 deprecated_print_address_numeric (load_addr
, 1, gdb_stdout
);
1077 printf_filtered (" in overlay section %s", section
->name
);
1079 printf_filtered (".\n");
1082 error (_("No symbol \"%s\" in current context."), exp
);
1086 printf_filtered ("Symbol \"");
1087 fprintf_symbol_filtered (gdb_stdout
, DEPRECATED_SYMBOL_NAME (sym
),
1088 current_language
->la_language
, DMGL_ANSI
);
1089 printf_filtered ("\" is ");
1090 val
= SYMBOL_VALUE (sym
);
1091 basereg
= SYMBOL_BASEREG (sym
);
1092 section
= SYMBOL_BFD_SECTION (sym
);
1094 switch (SYMBOL_CLASS (sym
))
1097 case LOC_CONST_BYTES
:
1098 printf_filtered ("constant");
1102 printf_filtered ("a label at address ");
1103 deprecated_print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1105 if (section_is_overlay (section
))
1107 load_addr
= overlay_unmapped_address (load_addr
, section
);
1108 printf_filtered (",\n -- loaded at ");
1109 deprecated_print_address_numeric (load_addr
, 1, gdb_stdout
);
1110 printf_filtered (" in overlay section %s", section
->name
);
1115 case LOC_COMPUTED_ARG
:
1116 /* FIXME: cagney/2004-01-26: It should be possible to
1117 unconditionally call the SYMBOL_OPS method when available.
1118 Unfortunately DWARF 2 stores the frame-base (instead of the
1119 function) location in a function's symbol. Oops! For the
1120 moment enable this when/where applicable. */
1121 SYMBOL_OPS (sym
)->describe_location (sym
, gdb_stdout
);
1125 printf_filtered (_("a variable in register %s"),
1126 gdbarch_register_name (current_gdbarch
, val
));
1130 printf_filtered (_("static storage at address "));
1131 deprecated_print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1133 if (section_is_overlay (section
))
1135 load_addr
= overlay_unmapped_address (load_addr
, section
);
1136 printf_filtered (_(",\n -- loaded at "));
1137 deprecated_print_address_numeric (load_addr
, 1, gdb_stdout
);
1138 printf_filtered (_(" in overlay section %s"), section
->name
);
1143 printf_filtered (_("external global (indirect addressing), at address *("));
1144 deprecated_print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1146 printf_filtered (")");
1147 if (section_is_overlay (section
))
1149 load_addr
= overlay_unmapped_address (load_addr
, section
);
1150 printf_filtered (_(",\n -- loaded at "));
1151 deprecated_print_address_numeric (load_addr
, 1, gdb_stdout
);
1152 printf_filtered (_(" in overlay section %s"), section
->name
);
1157 printf_filtered (_("an argument in register %s"),
1158 gdbarch_register_name (current_gdbarch
, val
));
1161 case LOC_REGPARM_ADDR
:
1162 printf_filtered (_("address of an argument in register %s"),
1163 gdbarch_register_name (current_gdbarch
, val
));
1167 printf_filtered (_("an argument at offset %ld"), val
);
1171 printf_filtered (_("an argument at frame offset %ld"), val
);
1175 printf_filtered (_("a local variable at frame offset %ld"), val
);
1179 printf_filtered (_("a reference argument at offset %ld"), val
);
1183 printf_filtered (_("a variable at offset %ld from register %s"),
1184 val
, gdbarch_register_name (current_gdbarch
, basereg
));
1187 case LOC_BASEREG_ARG
:
1188 printf_filtered (_("an argument at offset %ld from register %s"),
1189 val
, gdbarch_register_name (current_gdbarch
, basereg
));
1193 printf_filtered (_("a typedef"));
1197 printf_filtered (_("a function at address "));
1198 load_addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
1199 deprecated_print_address_numeric (load_addr
, 1, gdb_stdout
);
1200 if (section_is_overlay (section
))
1202 load_addr
= overlay_unmapped_address (load_addr
, section
);
1203 printf_filtered (_(",\n -- loaded at "));
1204 deprecated_print_address_numeric (load_addr
, 1, gdb_stdout
);
1205 printf_filtered (_(" in overlay section %s"), section
->name
);
1209 case LOC_UNRESOLVED
:
1211 struct minimal_symbol
*msym
;
1213 msym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym
), NULL
, NULL
);
1215 printf_filtered ("unresolved");
1218 section
= SYMBOL_BFD_SECTION (msym
);
1219 printf_filtered (_("static storage at address "));
1220 load_addr
= SYMBOL_VALUE_ADDRESS (msym
);
1221 deprecated_print_address_numeric (load_addr
, 1, gdb_stdout
);
1222 if (section_is_overlay (section
))
1224 load_addr
= overlay_unmapped_address (load_addr
, section
);
1225 printf_filtered (_(",\n -- loaded at "));
1226 deprecated_print_address_numeric (load_addr
, 1, gdb_stdout
);
1227 printf_filtered (_(" in overlay section %s"), section
->name
);
1233 case LOC_HP_THREAD_LOCAL_STATIC
:
1234 printf_filtered (_("\
1235 a thread-local variable at offset %ld from the thread base register %s"),
1236 val
, gdbarch_register_name (current_gdbarch
, basereg
));
1239 case LOC_OPTIMIZED_OUT
:
1240 printf_filtered (_("optimized out"));
1244 printf_filtered (_("of unknown (botched) type"));
1247 printf_filtered (".\n");
1252 x_command (char *exp
, int from_tty
)
1254 struct expression
*expr
;
1255 struct format_data fmt
;
1256 struct cleanup
*old_chain
;
1259 fmt
.format
= last_format
;
1260 fmt
.size
= last_size
;
1263 if (exp
&& *exp
== '/')
1266 fmt
= decode_format (&exp
, last_format
, last_size
);
1269 /* If we have an expression, evaluate it and use it as the address. */
1271 if (exp
!= 0 && *exp
!= 0)
1273 expr
= parse_expression (exp
);
1274 /* Cause expression not to be there any more if this command is
1275 repeated with Newline. But don't clobber a user-defined
1276 command's definition. */
1279 old_chain
= make_cleanup (free_current_contents
, &expr
);
1280 val
= evaluate_expression (expr
);
1281 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_REF
)
1282 val
= value_ind (val
);
1283 /* In rvalue contexts, such as this, functions are coerced into
1284 pointers to functions. This makes "x/i main" work. */
1285 if (/* last_format == 'i' && */
1286 TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
1287 && VALUE_LVAL (val
) == lval_memory
)
1288 next_address
= VALUE_ADDRESS (val
);
1290 next_address
= value_as_address (val
);
1291 do_cleanups (old_chain
);
1294 do_examine (fmt
, next_address
);
1296 /* If the examine succeeds, we remember its size and format for next
1298 last_size
= fmt
.size
;
1299 last_format
= fmt
.format
;
1301 /* Set a couple of internal variables if appropriate. */
1302 if (last_examine_value
)
1304 /* Make last address examined available to the user as $_. Use
1305 the correct pointer type. */
1306 struct type
*pointer_type
1307 = lookup_pointer_type (value_type (last_examine_value
));
1308 set_internalvar (lookup_internalvar ("_"),
1309 value_from_pointer (pointer_type
,
1310 last_examine_address
));
1312 /* Make contents of last address examined available to the user
1313 as $__. If the last value has not been fetched from memory
1314 then don't fetch it now; instead mark it by voiding the $__
1316 if (value_lazy (last_examine_value
))
1317 set_internalvar (lookup_internalvar ("__"),
1318 allocate_value (builtin_type_void
));
1320 set_internalvar (lookup_internalvar ("__"), last_examine_value
);
1325 /* Add an expression to the auto-display chain.
1326 Specify the expression. */
1329 display_command (char *exp
, int from_tty
)
1331 struct format_data fmt
;
1332 struct expression
*expr
;
1333 struct display
*new;
1337 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1339 if (tui_active
&& exp
!= NULL
&& *exp
== '$')
1340 display_it
= (tui_set_layout_for_display_command (exp
) == TUI_FAILURE
);
1354 fmt
= decode_format (&exp
, 0, 0);
1355 if (fmt
.size
&& fmt
.format
== 0)
1357 if (fmt
.format
== 'i' || fmt
.format
== 's')
1367 innermost_block
= 0;
1368 expr
= parse_expression (exp
);
1370 new = (struct display
*) xmalloc (sizeof (struct display
));
1373 new->block
= innermost_block
;
1374 new->next
= display_chain
;
1375 new->number
= ++display_number
;
1378 display_chain
= new;
1380 if (from_tty
&& target_has_execution
)
1381 do_one_display (new);
1388 free_display (struct display
*d
)
1394 /* Clear out the display_chain. Done when new symtabs are loaded,
1395 since this invalidates the types stored in many expressions. */
1398 clear_displays (void)
1402 while ((d
= display_chain
) != NULL
)
1405 display_chain
= d
->next
;
1410 /* Delete the auto-display number NUM. */
1413 delete_display (int num
)
1415 struct display
*d1
, *d
;
1418 error (_("No display number %d."), num
);
1420 if (display_chain
->number
== num
)
1423 display_chain
= d1
->next
;
1427 for (d
= display_chain
;; d
= d
->next
)
1430 error (_("No display number %d."), num
);
1431 if (d
->next
->number
== num
)
1441 /* Delete some values from the auto-display chain.
1442 Specify the element numbers. */
1445 undisplay_command (char *args
, int from_tty
)
1453 if (query ("Delete all auto-display expressions? "))
1462 while (*p1
>= '0' && *p1
<= '9')
1464 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1465 error (_("Arguments must be display numbers."));
1469 delete_display (num
);
1472 while (*p
== ' ' || *p
== '\t')
1478 /* Display a single auto-display.
1479 Do nothing if the display cannot be printed in the current context,
1480 or if the display is disabled. */
1483 do_one_display (struct display
*d
)
1485 int within_current_scope
;
1487 if (d
->enabled_p
== 0)
1491 within_current_scope
= contained_in (get_selected_block (0), d
->block
);
1493 within_current_scope
= 1;
1494 if (!within_current_scope
)
1497 current_display_number
= d
->number
;
1499 annotate_display_begin ();
1500 printf_filtered ("%d", d
->number
);
1501 annotate_display_number_end ();
1502 printf_filtered (": ");
1508 annotate_display_format ();
1510 printf_filtered ("x/");
1511 if (d
->format
.count
!= 1)
1512 printf_filtered ("%d", d
->format
.count
);
1513 printf_filtered ("%c", d
->format
.format
);
1514 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1515 printf_filtered ("%c", d
->format
.size
);
1516 printf_filtered (" ");
1518 annotate_display_expression ();
1520 print_expression (d
->exp
, gdb_stdout
);
1521 annotate_display_expression_end ();
1523 if (d
->format
.count
!= 1 || d
->format
.format
== 'i')
1524 printf_filtered ("\n");
1526 printf_filtered (" ");
1528 val
= evaluate_expression (d
->exp
);
1529 addr
= value_as_address (val
);
1530 if (d
->format
.format
== 'i')
1531 addr
= gdbarch_addr_bits_remove (current_gdbarch
, addr
);
1533 annotate_display_value ();
1535 do_examine (d
->format
, addr
);
1539 annotate_display_format ();
1541 if (d
->format
.format
)
1542 printf_filtered ("/%c ", d
->format
.format
);
1544 annotate_display_expression ();
1546 print_expression (d
->exp
, gdb_stdout
);
1547 annotate_display_expression_end ();
1549 printf_filtered (" = ");
1551 annotate_display_expression ();
1553 print_formatted (evaluate_expression (d
->exp
),
1554 d
->format
.format
, d
->format
.size
, gdb_stdout
);
1555 printf_filtered ("\n");
1558 annotate_display_end ();
1560 gdb_flush (gdb_stdout
);
1561 current_display_number
= -1;
1564 /* Display all of the values on the auto-display chain which can be
1565 evaluated in the current scope. */
1572 for (d
= display_chain
; d
; d
= d
->next
)
1576 /* Delete the auto-display which we were in the process of displaying.
1577 This is done when there is an error or a signal. */
1580 disable_display (int num
)
1584 for (d
= display_chain
; d
; d
= d
->next
)
1585 if (d
->number
== num
)
1590 printf_unfiltered (_("No display number %d.\n"), num
);
1594 disable_current_display (void)
1596 if (current_display_number
>= 0)
1598 disable_display (current_display_number
);
1599 fprintf_unfiltered (gdb_stderr
, _("\
1600 Disabling display %d to avoid infinite recursion.\n"),
1601 current_display_number
);
1603 current_display_number
= -1;
1607 display_info (char *ignore
, int from_tty
)
1612 printf_unfiltered (_("There are no auto-display expressions now.\n"));
1614 printf_filtered (_("Auto-display expressions now in effect:\n\
1615 Num Enb Expression\n"));
1617 for (d
= display_chain
; d
; d
= d
->next
)
1619 printf_filtered ("%d: %c ", d
->number
, "ny"[(int) d
->enabled_p
]);
1621 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
1623 else if (d
->format
.format
)
1624 printf_filtered ("/%c ", d
->format
.format
);
1625 print_expression (d
->exp
, gdb_stdout
);
1626 if (d
->block
&& !contained_in (get_selected_block (0), d
->block
))
1627 printf_filtered (_(" (cannot be evaluated in the current context)"));
1628 printf_filtered ("\n");
1629 gdb_flush (gdb_stdout
);
1634 enable_display (char *args
, int from_tty
)
1643 for (d
= display_chain
; d
; d
= d
->next
)
1650 while (*p1
>= '0' && *p1
<= '9')
1652 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1653 error (_("Arguments must be display numbers."));
1657 for (d
= display_chain
; d
; d
= d
->next
)
1658 if (d
->number
== num
)
1663 printf_unfiltered (_("No display number %d.\n"), num
);
1666 while (*p
== ' ' || *p
== '\t')
1672 disable_display_command (char *args
, int from_tty
)
1680 for (d
= display_chain
; d
; d
= d
->next
)
1687 while (*p1
>= '0' && *p1
<= '9')
1689 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1690 error (_("Arguments must be display numbers."));
1692 disable_display (atoi (p
));
1695 while (*p
== ' ' || *p
== '\t')
1701 /* Print the value in stack frame FRAME of a variable specified by a
1705 print_variable_value (struct symbol
*var
, struct frame_info
*frame
,
1706 struct ui_file
*stream
)
1708 struct value
*val
= read_var_value (var
, frame
);
1710 value_print (val
, stream
, 0, Val_pretty_default
);
1714 printf_command (char *arg
, int from_tty
)
1718 char *string
= NULL
;
1719 struct value
**val_args
;
1721 char *current_substring
;
1723 int allocated_args
= 20;
1724 struct cleanup
*old_cleanups
;
1726 val_args
= xmalloc (allocated_args
* sizeof (struct value
*));
1727 old_cleanups
= make_cleanup (free_current_contents
, &val_args
);
1730 error_no_arg (_("format-control string and values to print"));
1732 /* Skip white space before format string */
1733 while (*s
== ' ' || *s
== '\t')
1736 /* A format string should follow, enveloped in double quotes. */
1738 error (_("Bad format string, missing '\"'."));
1740 /* Parse the format-control string and copy it into the string STRING,
1741 processing some kinds of escape sequence. */
1743 f
= string
= (char *) alloca (strlen (s
) + 1);
1751 error (_("Bad format string, non-terminated '\"'."));
1784 /* ??? TODO: handle other escape sequences */
1785 error (_("Unrecognized escape character \\%c in format string."),
1795 /* Skip over " and following space and comma. */
1798 while (*s
== ' ' || *s
== '\t')
1801 if (*s
!= ',' && *s
!= 0)
1802 error (_("Invalid argument syntax"));
1806 while (*s
== ' ' || *s
== '\t')
1809 /* Need extra space for the '\0's. Doubling the size is sufficient. */
1810 substrings
= alloca (strlen (string
) * 2);
1811 current_substring
= substrings
;
1814 /* Now scan the string for %-specs and see what kinds of args they want.
1815 argclass[I] classifies the %-specs so we can give printf_filtered
1816 something of the right size. */
1820 int_arg
, long_arg
, long_long_arg
, ptr_arg
, string_arg
,
1821 double_arg
, long_double_arg
1823 enum argclass
*argclass
;
1824 enum argclass this_argclass
;
1829 argclass
= (enum argclass
*) alloca (strlen (s
) * sizeof *argclass
);
1836 int seen_hash
= 0, seen_zero
= 0, lcount
= 0, seen_prec
= 0;
1837 int seen_space
= 0, seen_plus
= 0;
1838 int seen_big_l
= 0, seen_h
= 0;
1841 /* Check the validity of the format specifier, and work
1842 out what argument it expects. We only accept C89
1843 format strings, with the exception of long long (which
1844 we autoconf for). */
1846 /* Skip over "%%". */
1853 /* The first part of a format specifier is a set of flag
1855 while (strchr ("0-+ #", *f
))
1868 /* The next part of a format specifier is a width. */
1869 while (strchr ("0123456789", *f
))
1872 /* The next part of a format specifier is a precision. */
1877 while (strchr ("0123456789", *f
))
1881 /* The next part of a format specifier is a length modifier. */
1913 if (seen_space
|| seen_plus
)
1920 this_argclass
= int_arg
;
1921 else if (lcount
== 1)
1922 this_argclass
= long_arg
;
1924 this_argclass
= long_long_arg
;
1931 this_argclass
= int_arg
;
1932 if (lcount
|| seen_h
|| seen_big_l
)
1934 if (seen_prec
|| seen_zero
|| seen_space
|| seen_plus
)
1939 this_argclass
= ptr_arg
;
1940 if (lcount
|| seen_h
|| seen_big_l
)
1942 if (seen_prec
|| seen_zero
|| seen_space
|| seen_plus
)
1947 this_argclass
= string_arg
;
1948 if (lcount
|| seen_h
|| seen_big_l
)
1950 if (seen_zero
|| seen_space
|| seen_plus
)
1960 this_argclass
= long_double_arg
;
1962 this_argclass
= double_arg
;
1964 if (lcount
|| seen_h
)
1969 error (_("`*' not supported for precision or width in printf"));
1972 error (_("Format specifier `n' not supported in printf"));
1975 error (_("Incomplete format specifier at end of format string"));
1978 error (_("Unrecognized format specifier '%c' in printf"), *f
);
1982 error (_("Inappropriate modifiers to format specifier '%c' in printf"),
1986 strncpy (current_substring
, last_arg
, f
- last_arg
);
1987 current_substring
+= f
- last_arg
;
1988 *current_substring
++ = '\0';
1990 argclass
[nargs_wanted
++] = this_argclass
;
1993 /* Now, parse all arguments and evaluate them.
1994 Store the VALUEs in VAL_ARGS. */
1999 if (nargs
== allocated_args
)
2000 val_args
= (struct value
**) xrealloc ((char *) val_args
,
2001 (allocated_args
*= 2)
2002 * sizeof (struct value
*));
2004 val_args
[nargs
] = parse_to_comma_and_eval (&s1
);
2006 /* If format string wants a float, unchecked-convert the value to
2007 floating point of the same size */
2009 if (argclass
[nargs
] == double_arg
)
2011 struct type
*type
= value_type (val_args
[nargs
]);
2012 if (TYPE_LENGTH (type
) == sizeof (float))
2013 deprecated_set_value_type (val_args
[nargs
], builtin_type_float
);
2014 if (TYPE_LENGTH (type
) == sizeof (double))
2015 deprecated_set_value_type (val_args
[nargs
], builtin_type_double
);
2023 if (nargs
!= nargs_wanted
)
2024 error (_("Wrong number of arguments for specified format-string"));
2026 /* Now actually print them. */
2027 current_substring
= substrings
;
2028 for (i
= 0; i
< nargs
; i
++)
2030 switch (argclass
[i
])
2037 tem
= value_as_address (val_args
[i
]);
2039 /* This is a %s argument. Find the length of the string. */
2044 read_memory (tem
+ j
, &c
, 1);
2049 /* Copy the string contents into a string inside GDB. */
2050 str
= (gdb_byte
*) alloca (j
+ 1);
2052 read_memory (tem
, str
, j
);
2055 printf_filtered (current_substring
, (char *) str
);
2060 double val
= value_as_double (val_args
[i
]);
2061 printf_filtered (current_substring
, val
);
2064 case long_double_arg
:
2065 #ifdef HAVE_LONG_DOUBLE
2067 long double val
= value_as_double (val_args
[i
]);
2068 printf_filtered (current_substring
, val
);
2072 error (_("long double not supported in printf"));
2075 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2077 long long val
= value_as_long (val_args
[i
]);
2078 printf_filtered (current_substring
, val
);
2082 error (_("long long not supported in printf"));
2086 int val
= value_as_long (val_args
[i
]);
2087 printf_filtered (current_substring
, val
);
2092 long val
= value_as_long (val_args
[i
]);
2093 printf_filtered (current_substring
, val
);
2097 internal_error (__FILE__
, __LINE__
,
2098 _("failed internal consitency check"));
2100 /* Skip to the next substring. */
2101 current_substring
+= strlen (current_substring
) + 1;
2103 /* Print the portion of the format string after the last argument. */
2104 puts_filtered (last_arg
);
2106 do_cleanups (old_cleanups
);
2110 _initialize_printcmd (void)
2112 struct cmd_list_element
*c
;
2114 current_display_number
= -1;
2116 add_info ("address", address_info
,
2117 _("Describe where symbol SYM is stored."));
2119 add_info ("symbol", sym_info
, _("\
2120 Describe what symbol is at location ADDR.\n\
2121 Only for symbols with fixed locations (global or static scope)."));
2123 add_com ("x", class_vars
, x_command
, _("\
2124 Examine memory: x/FMT ADDRESS.\n\
2125 ADDRESS is an expression for the memory address to examine.\n\
2126 FMT is a repeat count followed by a format letter and a size letter.\n\
2127 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2128 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n\
2129 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2130 The specified number of objects of the specified size are printed\n\
2131 according to the format.\n\n\
2132 Defaults for format and size letters are those previously used.\n\
2133 Default count is 1. Default address is following last thing printed\n\
2134 with this command or \"print\"."));
2137 add_com ("whereis", class_vars
, whereis_command
,
2138 _("Print line number and file of definition of variable."));
2141 add_info ("display", display_info
, _("\
2142 Expressions to display when program stops, with code numbers."));
2144 add_cmd ("undisplay", class_vars
, undisplay_command
, _("\
2145 Cancel some expressions to be displayed when program stops.\n\
2146 Arguments are the code numbers of the expressions to stop displaying.\n\
2147 No argument means cancel all automatic-display expressions.\n\
2148 \"delete display\" has the same effect as this command.\n\
2149 Do \"info display\" to see current list of code numbers."),
2152 add_com ("display", class_vars
, display_command
, _("\
2153 Print value of expression EXP each time the program stops.\n\
2154 /FMT may be used before EXP as in the \"print\" command.\n\
2155 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2156 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2157 and examining is done as in the \"x\" command.\n\n\
2158 With no argument, display all currently requested auto-display expressions.\n\
2159 Use \"undisplay\" to cancel display requests previously made."));
2161 add_cmd ("display", class_vars
, enable_display
, _("\
2162 Enable some expressions to be displayed when program stops.\n\
2163 Arguments are the code numbers of the expressions to resume displaying.\n\
2164 No argument means enable all automatic-display expressions.\n\
2165 Do \"info display\" to see current list of code numbers."), &enablelist
);
2167 add_cmd ("display", class_vars
, disable_display_command
, _("\
2168 Disable some expressions to be displayed when program stops.\n\
2169 Arguments are the code numbers of the expressions to stop displaying.\n\
2170 No argument means disable all automatic-display expressions.\n\
2171 Do \"info display\" to see current list of code numbers."), &disablelist
);
2173 add_cmd ("display", class_vars
, undisplay_command
, _("\
2174 Cancel some expressions to be displayed when program stops.\n\
2175 Arguments are the code numbers of the expressions to stop displaying.\n\
2176 No argument means cancel all automatic-display expressions.\n\
2177 Do \"info display\" to see current list of code numbers."), &deletelist
);
2179 add_com ("printf", class_vars
, printf_command
, _("\
2180 printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2181 This is useful for formatted output in user-defined commands."));
2183 add_com ("output", class_vars
, output_command
, _("\
2184 Like \"print\" but don't put in value history and don't print newline.\n\
2185 This is useful in user-defined commands."));
2187 add_prefix_cmd ("set", class_vars
, set_command
, _("\
2188 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2189 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2190 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2191 with $), a register (a few standard names starting with $), or an actual\n\
2192 variable in the program being debugged. EXP is any valid expression.\n\
2193 Use \"set variable\" for variables with names identical to set subcommands.\n\
2195 With a subcommand, this command modifies parts of the gdb environment.\n\
2196 You can see these environment settings with the \"show\" command."),
2197 &setlist
, "set ", 1, &cmdlist
);
2199 add_com ("assign", class_vars
, set_command
, _("\
2200 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2201 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2202 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2203 with $), a register (a few standard names starting with $), or an actual\n\
2204 variable in the program being debugged. EXP is any valid expression.\n\
2205 Use \"set variable\" for variables with names identical to set subcommands.\n\
2206 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2207 You can see these environment settings with the \"show\" command."));
2209 /* "call" is the same as "set", but handy for dbx users to call fns. */
2210 c
= add_com ("call", class_vars
, call_command
, _("\
2211 Call a function in the program.\n\
2212 The argument is the function name and arguments, in the notation of the\n\
2213 current working language. The result is printed and saved in the value\n\
2214 history, if it is not void."));
2215 set_cmd_completer (c
, location_completer
);
2217 add_cmd ("variable", class_vars
, set_command
, _("\
2218 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2219 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2220 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2221 with $), a register (a few standard names starting with $), or an actual\n\
2222 variable in the program being debugged. EXP is any valid expression.\n\
2223 This may usually be abbreviated to simply \"set\"."),
2226 c
= add_com ("print", class_vars
, print_command
, _("\
2227 Print value of expression EXP.\n\
2228 Variables accessible are those of the lexical environment of the selected\n\
2229 stack frame, plus all those whose scope is global or an entire file.\n\
2231 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2232 $$NUM refers to NUM'th value back from the last one.\n\
2233 Names starting with $ refer to registers (with the values they would have\n\
2234 if the program were to return to the stack frame now selected, restoring\n\
2235 all registers saved by frames farther in) or else to debugger\n\
2236 \"convenience\" variables (any such name not a known register).\n\
2237 Use assignment expressions to give values to convenience variables.\n\
2239 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2240 @ is a binary operator for treating consecutive data objects\n\
2241 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2242 element is FOO, whose second element is stored in the space following\n\
2243 where FOO is stored, etc. FOO must be an expression whose value\n\
2244 resides in memory.\n\
2246 EXP may be preceded with /FMT, where FMT is a format letter\n\
2247 but no count or size letter (see \"x\" command)."));
2248 set_cmd_completer (c
, location_completer
);
2249 add_com_alias ("p", "print", class_vars
, 1);
2251 c
= add_com ("inspect", class_vars
, inspect_command
, _("\
2252 Same as \"print\" command, except that if you are running in the epoch\n\
2253 environment, the value is printed in its own window."));
2254 set_cmd_completer (c
, location_completer
);
2256 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class
,
2257 &max_symbolic_offset
, _("\
2258 Set the largest offset that will be printed in <symbol+1234> form."), _("\
2259 Show the largest offset that will be printed in <symbol+1234> form."), NULL
,
2261 show_max_symbolic_offset
,
2262 &setprintlist
, &showprintlist
);
2263 add_setshow_boolean_cmd ("symbol-filename", no_class
,
2264 &print_symbol_filename
, _("\
2265 Set printing of source filename and line number with <symbol>."), _("\
2266 Show printing of source filename and line number with <symbol>."), NULL
,
2268 show_print_symbol_filename
,
2269 &setprintlist
, &showprintlist
);
2271 /* For examine/instruction a single byte quantity is specified as
2272 the data. This avoids problems with value_at_lazy() requiring a
2273 valid data type (and rejecting VOID). */
2274 examine_i_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_i_type", NULL
);
2276 examine_b_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_b_type", NULL
);
2277 examine_h_type
= init_type (TYPE_CODE_INT
, 2, 0, "examine_h_type", NULL
);
2278 examine_w_type
= init_type (TYPE_CODE_INT
, 4, 0, "examine_w_type", NULL
);
2279 examine_g_type
= init_type (TYPE_CODE_INT
, 8, 0, "examine_g_type", NULL
);