1 /* Print values for GNU debugger GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1993, 1994, 1995
3 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 2 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, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #include "gdb_string.h"
28 #include "expression.h"
32 #include "breakpoint.h"
36 #include "symfile.h" /* for overlay functions */
37 #include "objfiles.h" /* ditto */
39 extern int asm_demangle
; /* Whether to demangle syms in asm printouts */
40 extern int addressprint
; /* Whether to print hex addresses in HLL " */
49 /* Last specified output format. */
51 static char last_format
= 'x';
53 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
55 static char last_size
= 'w';
57 /* Default address to examine next. */
59 static CORE_ADDR next_address
;
61 /* Default section to examine next. */
63 static asection
*next_section
;
65 /* Last address examined. */
67 static CORE_ADDR last_examine_address
;
69 /* Contents of last address examined.
70 This is not valid past the end of the `x' command! */
72 static value_ptr last_examine_value
;
74 /* Largest offset between a symbolic value and an address, that will be
75 printed as `0x1234 <symbol+offset>'. */
77 static unsigned int max_symbolic_offset
= UINT_MAX
;
79 /* Append the source filename and linenumber of the symbol when
80 printing a symbolic value as `<symbol at filename:linenum>' if set. */
81 static int print_symbol_filename
= 0;
83 /* Number of auto-display expression currently being displayed.
84 So that we can disable it if we get an error or a signal within it.
85 -1 when not doing one. */
87 int current_display_number
;
89 /* Flag to low-level print routines that this value is being printed
90 in an epoch window. We'd like to pass this as a parameter, but
91 every routine would need to take it. Perhaps we can encapsulate
92 this in the I/O stream once we have GNU stdio. */
98 /* Chain link to next auto-display item. */
100 /* Expression to be evaluated and displayed. */
101 struct expression
*exp
;
102 /* Item number of this auto-display item. */
104 /* Display format specified. */
105 struct format_data format
;
106 /* Innermost block required by this expression when evaluated */
108 /* Status of this display (enabled or disabled) */
112 /* Chain of expressions whose values should be displayed
113 automatically each time the program stops. */
115 static struct display
*display_chain
;
117 static int display_number
;
119 /* Pointer to the target-dependent disassembly function. */
121 int (*tm_print_insn
) PARAMS ((bfd_vma
, disassemble_info
*));
122 disassemble_info tm_print_insn_info
;
124 /* Functions exported for general use: */
126 void output_command
PARAMS ((char *, int));
129 /* Prototypes for local functions. */
131 static void delete_display
PARAMS ((int));
133 static void enable_display
PARAMS ((char *, int));
135 static void disable_display_command
PARAMS ((char *, int));
137 static void disassemble_command
PARAMS ((char *, int));
139 static void printf_command
PARAMS ((char *, int));
141 static void print_frame_nameless_args
PARAMS ((struct frame_info
*, long,
142 int, int, GDB_FILE
*));
144 static void display_info
PARAMS ((char *, int));
146 static void do_one_display
PARAMS ((struct display
*));
148 static void undisplay_command
PARAMS ((char *, int));
150 static void free_display
PARAMS ((struct display
*));
152 static void display_command
PARAMS ((char *, int));
154 void x_command
PARAMS ((char *, int));
156 static void address_info
PARAMS ((char *, int));
158 static void set_command
PARAMS ((char *, int));
160 static void call_command
PARAMS ((char *, int));
162 static void inspect_command
PARAMS ((char *, int));
164 static void print_command
PARAMS ((char *, int));
166 static void print_command_1
PARAMS ((char *, int, int));
168 static void validate_format
PARAMS ((struct format_data
, char *));
170 static void do_examine
PARAMS ((struct format_data
, CORE_ADDR addr
, asection
*section
));
172 static void print_formatted
PARAMS ((value_ptr
, int, int));
174 static struct format_data decode_format
PARAMS ((char **, int, int));
176 static int print_insn
PARAMS ((CORE_ADDR
, GDB_FILE
*));
179 /* Decode a format specification. *STRING_PTR should point to it.
180 OFORMAT and OSIZE are used as defaults for the format and size
181 if none are given in the format specification.
182 If OSIZE is zero, then the size field of the returned value
183 should be set only if a size is explicitly specified by the
185 The structure returned describes all the data
186 found in the specification. In addition, *STRING_PTR is advanced
187 past the specification and past all whitespace following it. */
189 static struct format_data
190 decode_format (string_ptr
, oformat
, osize
)
195 struct format_data val
;
196 register char *p
= *string_ptr
;
202 if (*p
>= '0' && *p
<= '9')
203 val
.count
= atoi (p
);
204 while (*p
>= '0' && *p
<= '9') p
++;
206 /* Now process size or format letters that follow. */
210 if (*p
== 'b' || *p
== 'h' || *p
== 'w' || *p
== 'g')
212 else if (*p
>= 'a' && *p
<= 'z')
218 while (*p
== ' ' || *p
== '\t') p
++;
221 /* Set defaults for format and size if not specified. */
222 if (val
.format
== '?')
226 /* Neither has been specified. */
227 val
.format
= oformat
;
231 /* If a size is specified, any format makes a reasonable
232 default except 'i'. */
233 val
.format
= oformat
== 'i' ? 'x' : oformat
;
235 else if (val
.size
== '?')
240 /* Pick the appropriate size for an address. */
241 if (TARGET_PTR_BIT
== 64)
242 val
.size
= osize
? 'g' : osize
;
243 else if (TARGET_PTR_BIT
== 32)
244 val
.size
= osize
? 'w' : osize
;
245 else if (TARGET_PTR_BIT
== 16)
246 val
.size
= osize
? 'h' : osize
;
248 /* Bad value for TARGET_PTR_BIT */
252 /* Floating point has to be word or giantword. */
253 if (osize
== 'w' || osize
== 'g')
256 /* Default it to giantword if the last used size is not
258 val
.size
= osize
? 'g' : osize
;
261 /* Characters default to one byte. */
262 val
.size
= osize
? 'b' : osize
;
265 /* The default is the size most recently specified. */
272 /* Print value VAL on gdb_stdout according to FORMAT, a letter or 0.
273 Do not end with a newline.
274 0 means print VAL according to its own type.
275 SIZE is the letter for the size of datum being printed.
276 This is used to pad hex numbers so they line up. */
279 print_formatted (val
, format
, size
)
280 register value_ptr val
;
284 struct type
*type
= check_typedef (VALUE_TYPE (val
));
285 int len
= TYPE_LENGTH (type
);
287 if (VALUE_LVAL (val
) == lval_memory
)
289 next_address
= VALUE_ADDRESS (val
) + len
;
290 next_section
= VALUE_BFD_SECTION (val
);
296 /* FIXME: Need to handle wchar_t's here... */
297 next_address
= VALUE_ADDRESS (val
)
298 + val_print_string (VALUE_ADDRESS (val
), -1, 1, gdb_stdout
);
299 next_section
= VALUE_BFD_SECTION (val
);
303 /* The old comment says
304 "Force output out, print_insn not using _filtered".
305 I'm not completely sure what that means, I suspect most print_insn
306 now do use _filtered, so I guess it's obsolete. */
307 /* We often wrap here if there are long symbolic names. */
309 next_address
= VALUE_ADDRESS (val
)
310 + print_insn (VALUE_ADDRESS (val
), gdb_stdout
);
311 next_section
= VALUE_BFD_SECTION (val
);
316 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
317 || TYPE_CODE (type
) == TYPE_CODE_STRING
318 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
319 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
320 value_print (val
, gdb_stdout
, format
, Val_pretty_default
);
322 print_scalar_formatted (VALUE_CONTENTS (val
), type
,
323 format
, size
, gdb_stdout
);
327 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
328 according to letters FORMAT and SIZE on STREAM.
329 FORMAT may not be zero. Formats s and i are not supported at this level.
331 This is how the elements of an array or structure are printed
335 print_scalar_formatted (valaddr
, type
, format
, size
, stream
)
343 unsigned int len
= TYPE_LENGTH (type
);
345 if (len
> sizeof (LONGEST
)
353 if (! TYPE_UNSIGNED (type
)
354 || ! extract_long_unsigned_integer (valaddr
, len
, &val_long
))
356 /* We can't print it normally, but we can print it in hex.
357 Printing it in the wrong radix is more useful than saying
358 "use /x, you dummy". */
359 /* FIXME: we could also do octal or binary if that was the
361 /* FIXME: we should be using the size field to give us a
362 minimum field width to print. */
363 val_print_type_code_int (type
, valaddr
, stream
);
367 /* If we get here, extract_long_unsigned_integer set val_long. */
369 else if (format
!= 'f')
370 val_long
= unpack_long (type
, valaddr
);
372 /* If we are printing it as unsigned, truncate it in case it is actually
373 a negative signed value (e.g. "print/u (short)-1" should print 65535
374 (if shorts are 16 bits) instead of 4294967295). */
377 if (len
< sizeof (LONGEST
))
378 val_long
&= ((LONGEST
) 1 << HOST_CHAR_BIT
* len
) - 1;
386 /* no size specified, like in print. Print varying # of digits. */
387 print_longest (stream
, 'x', 1, val_long
);
396 print_longest (stream
, size
, 1, val_long
);
399 error ("Undefined output size \"%c\".", size
);
404 print_longest (stream
, 'd', 1, val_long
);
408 print_longest (stream
, 'u', 0, val_long
);
413 print_longest (stream
, 'o', 1, val_long
);
415 fprintf_filtered (stream
, "0");
419 print_address (unpack_pointer (type
, valaddr
), stream
);
423 value_print (value_from_longest (builtin_type_char
, val_long
), stream
, 0,
428 if (len
== sizeof (float))
429 type
= builtin_type_float
;
430 else if (len
== sizeof (double))
431 type
= builtin_type_double
;
432 print_floating (valaddr
, type
, stream
);
439 /* Binary; 't' stands for "two". */
441 char bits
[8*(sizeof val_long
) + 1];
446 width
= 8*(sizeof val_long
);
463 error ("Undefined output size \"%c\".", size
);
469 bits
[width
] = (val_long
& 1) ? '1' : '0';
474 while (*cp
&& *cp
== '0')
479 fprintf_filtered (stream
, local_binary_format_prefix());
480 fprintf_filtered (stream
, cp
);
481 fprintf_filtered (stream
, local_binary_format_suffix());
486 error ("Undefined output format \"%c\".", format
);
490 /* Specify default address for `x' command.
491 `info lines' uses this. */
494 set_next_address (addr
)
499 /* Make address available to the user as $_. */
500 set_internalvar (lookup_internalvar ("_"),
501 value_from_longest (lookup_pointer_type (builtin_type_void
),
505 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
506 after LEADIN. Print nothing if no symbolic name is found nearby.
507 Optionally also print source file and line number, if available.
508 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
509 or to interpret it as a possible C++ name and convert it back to source
510 form. However note that DO_DEMANGLE can be overridden by the specific
511 settings of the demangle and asm_demangle variables. */
514 print_address_symbolic (addr
, stream
, do_demangle
, leadin
)
520 struct minimal_symbol
*msymbol
;
521 struct symbol
*symbol
;
522 struct symtab
*symtab
= 0;
523 CORE_ADDR name_location
= 0;
525 asection
*section
= 0;
528 /* Determine if the address is in an overlay, and whether it is mapped. */
529 if (overlay_debugging
)
531 section
= find_pc_overlay (addr
);
532 if (pc_in_unmapped_range (addr
, section
))
535 addr
= overlay_mapped_address (addr
, section
);
539 /* On some targets, add in extra "flag" bits to PC for
540 disassembly. This should ensure that "rounding errors" in
541 symbol addresses that are masked for disassembly favour the
542 the correct symbol. */
544 #ifdef GDB_TARGET_UNMASK_DISAS_PC
545 addr
= GDB_TARGET_UNMASK_DISAS_PC (addr
);
548 /* First try to find the address in the symbol table, then
549 in the minsyms. Take the closest one. */
551 /* This is defective in the sense that it only finds text symbols. So
552 really this is kind of pointless--we should make sure that the
553 minimal symbols have everything we need (by changing that we could
554 save some memory, but for many debug format--ELF/DWARF or
555 anything/stabs--it would be inconvenient to eliminate those minimal
557 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
558 symbol
= find_pc_sect_function (addr
, section
);
562 name_location
= BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
));
564 name
= SYMBOL_SOURCE_NAME (symbol
);
566 name
= SYMBOL_LINKAGE_NAME (symbol
);
571 if (SYMBOL_VALUE_ADDRESS (msymbol
) > name_location
|| symbol
== NULL
)
573 /* The msymbol is closer to the address than the symbol;
574 use the msymbol instead. */
577 name_location
= SYMBOL_VALUE_ADDRESS (msymbol
);
579 name
= SYMBOL_SOURCE_NAME (msymbol
);
581 name
= SYMBOL_LINKAGE_NAME (msymbol
);
584 if (symbol
== NULL
&& msymbol
== NULL
)
587 /* On some targets, mask out extra "flag" bits from PC for handsome
590 #ifdef GDB_TARGET_MASK_DISAS_PC
591 name_location
= GDB_TARGET_MASK_DISAS_PC (name_location
);
592 addr
= GDB_TARGET_MASK_DISAS_PC (addr
);
595 /* If the nearest symbol is too far away, don't print anything symbolic. */
597 /* For when CORE_ADDR is larger than unsigned int, we do math in
598 CORE_ADDR. But when we detect unsigned wraparound in the
599 CORE_ADDR math, we ignore this test and print the offset,
600 because addr+max_symbolic_offset has wrapped through the end
601 of the address space back to the beginning, giving bogus comparison. */
602 if (addr
> name_location
+ max_symbolic_offset
603 && name_location
+ max_symbolic_offset
> name_location
)
606 fputs_filtered (leadin
, stream
);
608 fputs_filtered ("<*", stream
);
610 fputs_filtered ("<", stream
);
611 fputs_filtered (name
, stream
);
612 if (addr
!= name_location
)
613 fprintf_filtered (stream
, "+%u", (unsigned int)(addr
- name_location
));
615 /* Append source filename and line number if desired. Give specific
616 line # of this addr, if we have it; else line # of the nearest symbol. */
617 if (print_symbol_filename
)
619 struct symtab_and_line sal
;
621 sal
= find_pc_sect_line (addr
, section
, 0);
624 fprintf_filtered (stream
, " at %s:%d", sal
.symtab
->filename
, sal
.line
);
625 else if (symtab
&& symbol
&& symbol
->line
)
626 fprintf_filtered (stream
, " at %s:%d", symtab
->filename
, symbol
->line
);
628 fprintf_filtered (stream
, " in %s", symtab
->filename
);
631 fputs_filtered ("*>", stream
);
633 fputs_filtered (">", stream
);
636 /* Print address ADDR on STREAM. USE_LOCAL means the same thing as for
639 print_address_numeric (addr
, use_local
, stream
)
644 /* This assumes a CORE_ADDR can fit in a LONGEST. Probably a safe
646 print_longest (stream
, 'x', use_local
, (ULONGEST
) addr
);
649 /* Print address ADDR symbolically on STREAM.
650 First print it as a number. Then perhaps print
651 <SYMBOL + OFFSET> after the number. */
654 print_address (addr
, stream
)
658 print_address_numeric (addr
, 1, stream
);
659 print_address_symbolic (addr
, stream
, asm_demangle
, " ");
662 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
663 controls whether to print the symbolic name "raw" or demangled.
664 Global setting "addressprint" controls whether to print hex address
668 print_address_demangle (addr
, stream
, do_demangle
)
675 fprintf_filtered (stream
, "0");
677 else if (addressprint
)
679 print_address_numeric (addr
, 1, stream
);
680 print_address_symbolic (addr
, stream
, do_demangle
, " ");
684 print_address_symbolic (addr
, stream
, do_demangle
, "");
689 /* These are the types that $__ will get after an examine command of one
692 static struct type
*examine_i_type
;
694 static struct type
*examine_b_type
;
695 static struct type
*examine_h_type
;
696 static struct type
*examine_w_type
;
697 static struct type
*examine_g_type
;
699 /* Examine data at address ADDR in format FMT.
700 Fetch it from memory and print on gdb_stdout. */
703 do_examine (fmt
, addr
, sect
)
704 struct format_data fmt
;
708 register char format
= 0;
710 register int count
= 1;
711 struct type
*val_type
= NULL
;
713 register int maxelts
;
721 /* String or instruction format implies fetch single bytes
722 regardless of the specified size. */
723 if (format
== 's' || format
== 'i')
727 val_type
= examine_i_type
;
728 else if (size
== 'b')
729 val_type
= examine_b_type
;
730 else if (size
== 'h')
731 val_type
= examine_h_type
;
732 else if (size
== 'w')
733 val_type
= examine_w_type
;
734 else if (size
== 'g')
735 val_type
= examine_g_type
;
742 if (format
== 's' || format
== 'i')
745 /* Print as many objects as specified in COUNT, at most maxelts per line,
746 with the address of the next one at the start of each line. */
751 print_address (next_address
, gdb_stdout
);
752 printf_filtered (":");
757 printf_filtered ("\t");
758 /* Note that print_formatted sets next_address for the next
760 last_examine_address
= next_address
;
761 /* The value to be displayed is not fetched greedily.
762 Instead, to avoid the posibility of a fetched value not
763 being used, its retreval is delayed until the print code
764 uses it. When examining an instruction stream, the
765 disassembler will perform its own memory fetch using just
766 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
767 the disassembler be modified so that LAST_EXAMINE_VALUE
768 is left with the byte sequence from the last complete
769 instruction fetched from memory? */
770 last_examine_value
= value_at_lazy (val_type
, next_address
, sect
);
771 print_formatted (last_examine_value
, format
, size
);
773 printf_filtered ("\n");
774 gdb_flush (gdb_stdout
);
779 validate_format (fmt
, cmdname
)
780 struct format_data fmt
;
784 error ("Size letters are meaningless in \"%s\" command.", cmdname
);
786 error ("Item count other than 1 is meaningless in \"%s\" command.",
788 if (fmt
.format
== 'i' || fmt
.format
== 's')
789 error ("Format letter \"%c\" is meaningless in \"%s\" command.",
790 fmt
.format
, cmdname
);
793 /* Evaluate string EXP as an expression in the current language and
794 print the resulting value. EXP may contain a format specifier as the
795 first argument ("/x myvar" for example, to print myvar in hex).
799 print_command_1 (exp
, inspect
, voidprint
)
804 struct expression
*expr
;
805 register struct cleanup
*old_chain
= 0;
806 register char format
= 0;
807 register value_ptr val
;
808 struct format_data fmt
;
811 /* Pass inspect flag to the rest of the print routines in a global (sigh). */
812 inspect_it
= inspect
;
814 if (exp
&& *exp
== '/')
817 fmt
= decode_format (&exp
, last_format
, 0);
818 validate_format (fmt
, "print");
819 last_format
= format
= fmt
.format
;
830 extern int objectprint
;
832 expr
= parse_expression (exp
);
833 old_chain
= make_cleanup (free_current_contents
, &expr
);
835 val
= evaluate_expression (expr
);
837 /* C++: figure out what type we actually want to print it as. */
838 type
= VALUE_TYPE (val
);
841 && ( TYPE_CODE (type
) == TYPE_CODE_PTR
842 || TYPE_CODE (type
) == TYPE_CODE_REF
)
843 && ( TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
844 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_UNION
))
848 v
= value_from_vtable_info (val
, TYPE_TARGET_TYPE (type
));
852 type
= VALUE_TYPE (val
);
857 val
= access_value_history (0);
859 if (voidprint
|| (val
&& VALUE_TYPE (val
) &&
860 TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_VOID
))
862 int histindex
= record_latest_value (val
);
865 annotate_value_history_begin (histindex
, VALUE_TYPE (val
));
867 annotate_value_begin (VALUE_TYPE (val
));
870 printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"", exp
, histindex
);
872 if (histindex
>= 0) printf_filtered ("$%d = ", histindex
);
875 annotate_value_history_value ();
877 print_formatted (val
, format
, fmt
.size
);
878 printf_filtered ("\n");
881 annotate_value_history_end ();
883 annotate_value_end ();
886 printf_unfiltered("\") )\030");
890 do_cleanups (old_chain
);
891 inspect_it
= 0; /* Reset print routines to normal */
896 print_command (exp
, from_tty
)
900 print_command_1 (exp
, 0, 1);
903 /* Same as print, except in epoch, it gets its own window */
906 inspect_command (exp
, from_tty
)
910 extern int epoch_interface
;
912 print_command_1 (exp
, epoch_interface
, 1);
915 /* Same as print, except it doesn't print void results. */
918 call_command (exp
, from_tty
)
922 print_command_1 (exp
, 0, 0);
927 output_command (exp
, from_tty
)
931 struct expression
*expr
;
932 register struct cleanup
*old_chain
;
933 register char format
= 0;
934 register value_ptr val
;
935 struct format_data fmt
;
937 if (exp
&& *exp
== '/')
940 fmt
= decode_format (&exp
, 0, 0);
941 validate_format (fmt
, "output");
945 expr
= parse_expression (exp
);
946 old_chain
= make_cleanup (free_current_contents
, &expr
);
948 val
= evaluate_expression (expr
);
950 annotate_value_begin (VALUE_TYPE (val
));
952 print_formatted (val
, format
, fmt
.size
);
954 annotate_value_end ();
956 do_cleanups (old_chain
);
961 set_command (exp
, from_tty
)
965 struct expression
*expr
= parse_expression (exp
);
966 register struct cleanup
*old_chain
967 = make_cleanup (free_current_contents
, &expr
);
968 evaluate_expression (expr
);
969 do_cleanups (old_chain
);
974 sym_info (arg
, from_tty
)
978 struct minimal_symbol
*msymbol
;
979 struct objfile
*objfile
;
980 struct obj_section
*osect
;
982 CORE_ADDR addr
, sect_addr
;
987 error_no_arg ("address");
989 addr
= parse_and_eval_address (arg
);
990 ALL_OBJSECTIONS (objfile
, osect
)
992 sect
= osect
->the_bfd_section
;
993 sect_addr
= overlay_mapped_address (addr
, sect
);
995 if (osect
->addr
<= sect_addr
&& sect_addr
< osect
->endaddr
&&
996 (msymbol
= lookup_minimal_symbol_by_pc_section (sect_addr
, sect
)))
999 offset
= sect_addr
- SYMBOL_VALUE_ADDRESS (msymbol
);
1001 printf_filtered ("%s + %u in ",
1002 SYMBOL_SOURCE_NAME (msymbol
), offset
);
1004 printf_filtered ("%s in ",
1005 SYMBOL_SOURCE_NAME (msymbol
));
1006 if (pc_in_unmapped_range (addr
, sect
))
1007 printf_filtered ("load address range of ");
1008 if (section_is_overlay (sect
))
1009 printf_filtered ("%s overlay ",
1010 section_is_mapped (sect
) ? "mapped" : "unmapped");
1011 printf_filtered ("section %s", sect
->name
);
1012 printf_filtered ("\n");
1016 printf_filtered ("No symbol matches %s.\n", arg
);
1021 address_info (exp
, from_tty
)
1025 register struct symbol
*sym
;
1026 register struct minimal_symbol
*msymbol
;
1028 register long basereg
;
1030 CORE_ADDR load_addr
;
1031 int is_a_field_of_this
; /* C++: lookup_symbol sets this to nonzero
1032 if exp is a field of `this'. */
1035 error ("Argument required.");
1037 sym
= lookup_symbol (exp
, get_selected_block (), VAR_NAMESPACE
,
1038 &is_a_field_of_this
, (struct symtab
**)NULL
);
1041 if (is_a_field_of_this
)
1043 printf_filtered ("Symbol \"");
1044 fprintf_symbol_filtered (gdb_stdout
, exp
,
1045 current_language
->la_language
, DMGL_ANSI
);
1046 printf_filtered ("\" is a field of the local class variable `this'\n");
1050 msymbol
= lookup_minimal_symbol (exp
, NULL
, NULL
);
1052 if (msymbol
!= NULL
)
1054 load_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1056 printf_filtered ("Symbol \"");
1057 fprintf_symbol_filtered (gdb_stdout
, exp
,
1058 current_language
->la_language
, DMGL_ANSI
);
1059 printf_filtered ("\" is at ");
1060 print_address_numeric (load_addr
, 1, gdb_stdout
);
1061 printf_filtered (" in a file compiled without debugging");
1062 section
= SYMBOL_BFD_SECTION (msymbol
);
1063 if (section_is_overlay (section
))
1065 load_addr
= overlay_unmapped_address (load_addr
, section
);
1066 printf_filtered (",\n -- loaded at ");
1067 print_address_numeric (load_addr
, 1, gdb_stdout
);
1068 printf_filtered (" in overlay section %s", section
->name
);
1070 printf_filtered (".\n");
1073 error ("No symbol \"%s\" in current context.", exp
);
1077 printf_filtered ("Symbol \"");
1078 fprintf_symbol_filtered (gdb_stdout
, SYMBOL_NAME (sym
),
1079 current_language
->la_language
, DMGL_ANSI
);
1080 printf_filtered ("\" is ");
1081 val
= SYMBOL_VALUE (sym
);
1082 basereg
= SYMBOL_BASEREG (sym
);
1083 section
= SYMBOL_BFD_SECTION (sym
);
1085 switch (SYMBOL_CLASS (sym
))
1088 case LOC_CONST_BYTES
:
1089 printf_filtered ("constant");
1093 printf_filtered ("a label at address ");
1094 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1096 if (section_is_overlay (section
))
1098 load_addr
= overlay_unmapped_address (load_addr
, section
);
1099 printf_filtered (",\n -- loaded at ");
1100 print_address_numeric (load_addr
, 1, gdb_stdout
);
1101 printf_filtered (" in overlay section %s", section
->name
);
1106 printf_filtered ("a variable in register %s", reg_names
[val
]);
1110 printf_filtered ("static storage at address ");
1111 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1113 if (section_is_overlay (section
))
1115 load_addr
= overlay_unmapped_address (load_addr
, section
);
1116 printf_filtered (",\n -- loaded at ");
1117 print_address_numeric (load_addr
, 1, gdb_stdout
);
1118 printf_filtered (" in overlay section %s", section
->name
);
1123 printf_filtered ("an argument in register %s", reg_names
[val
]);
1126 case LOC_REGPARM_ADDR
:
1127 printf_filtered ("address of an argument in register %s", reg_names
[val
]);
1131 printf_filtered ("an argument at offset %ld", val
);
1135 printf_filtered ("an argument at frame offset %ld", val
);
1139 printf_filtered ("a local variable at frame offset %ld", val
);
1143 printf_filtered ("a reference argument at offset %ld", val
);
1147 printf_filtered ("a variable at offset %ld from register %s",
1148 val
, reg_names
[basereg
]);
1151 case LOC_BASEREG_ARG
:
1152 printf_filtered ("an argument at offset %ld from register %s",
1153 val
, reg_names
[basereg
]);
1157 printf_filtered ("a typedef");
1161 printf_filtered ("a function at address ");
1162 #ifdef GDB_TARGET_MASK_DISAS_PC
1163 print_address_numeric
1164 (load_addr
= GDB_TARGET_MASK_DISAS_PC (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))),
1167 print_address_numeric (load_addr
=BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)),
1170 if (section_is_overlay (section
))
1172 load_addr
= overlay_unmapped_address (load_addr
, section
);
1173 printf_filtered (",\n -- loaded at ");
1174 print_address_numeric (load_addr
, 1, gdb_stdout
);
1175 printf_filtered (" in overlay section %s", section
->name
);
1179 case LOC_UNRESOLVED
:
1181 struct minimal_symbol
*msym
;
1183 msym
= lookup_minimal_symbol (SYMBOL_NAME (sym
), NULL
, NULL
);
1185 printf_filtered ("unresolved");
1188 section
= SYMBOL_BFD_SECTION (msym
);
1189 printf_filtered ("static storage at address ");
1190 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (msym
),
1192 if (section_is_overlay (section
))
1194 load_addr
= overlay_unmapped_address (load_addr
, section
);
1195 printf_filtered (",\n -- loaded at ");
1196 print_address_numeric (load_addr
, 1, gdb_stdout
);
1197 printf_filtered (" in overlay section %s", section
->name
);
1203 case LOC_OPTIMIZED_OUT
:
1204 printf_filtered ("optimized out");
1208 printf_filtered ("of unknown (botched) type");
1211 printf_filtered (".\n");
1215 x_command (exp
, from_tty
)
1219 struct expression
*expr
;
1220 struct format_data fmt
;
1221 struct cleanup
*old_chain
;
1224 fmt
.format
= last_format
;
1225 fmt
.size
= last_size
;
1228 if (exp
&& *exp
== '/')
1231 fmt
= decode_format (&exp
, last_format
, last_size
);
1234 /* If we have an expression, evaluate it and use it as the address. */
1236 if (exp
!= 0 && *exp
!= 0)
1238 expr
= parse_expression (exp
);
1239 /* Cause expression not to be there any more
1240 if this command is repeated with Newline.
1241 But don't clobber a user-defined command's definition. */
1244 old_chain
= make_cleanup (free_current_contents
, &expr
);
1245 val
= evaluate_expression (expr
);
1246 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_REF
)
1247 val
= value_ind (val
);
1248 /* In rvalue contexts, such as this, functions are coerced into
1249 pointers to functions. This makes "x/i main" work. */
1250 if (/* last_format == 'i'
1251 && */ TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FUNC
1252 && VALUE_LVAL (val
) == lval_memory
)
1253 next_address
= VALUE_ADDRESS (val
);
1255 next_address
= value_as_pointer (val
);
1256 if (VALUE_BFD_SECTION (val
))
1257 next_section
= VALUE_BFD_SECTION (val
);
1258 do_cleanups (old_chain
);
1261 do_examine (fmt
, next_address
, next_section
);
1263 /* If the examine succeeds, we remember its size and format for next time. */
1264 last_size
= fmt
.size
;
1265 last_format
= fmt
.format
;
1267 /* Set a couple of internal variables if appropriate. */
1268 if (last_examine_value
)
1270 /* Make last address examined available to the user as $_. Use
1271 the correct pointer type. */
1272 set_internalvar (lookup_internalvar ("_"),
1273 value_from_longest (
1274 lookup_pointer_type (VALUE_TYPE (last_examine_value
)),
1275 (LONGEST
) last_examine_address
));
1277 /* Make contents of last address examined available to the user as $__.*/
1278 /* If the last value has not been fetched from memory then don't
1279 fetch it now - instead mark it by voiding the $__ variable. */
1280 if (VALUE_LAZY (last_examine_value
))
1281 set_internalvar (lookup_internalvar ("__"),
1282 allocate_value (builtin_type_void
));
1284 set_internalvar (lookup_internalvar ("__"), last_examine_value
);
1289 /* Add an expression to the auto-display chain.
1290 Specify the expression. */
1293 display_command (exp
, from_tty
)
1297 struct format_data fmt
;
1298 register struct expression
*expr
;
1299 register struct display
*new;
1310 fmt
= decode_format (&exp
, 0, 0);
1311 if (fmt
.size
&& fmt
.format
== 0)
1313 if (fmt
.format
== 'i' || fmt
.format
== 's')
1323 innermost_block
= 0;
1324 expr
= parse_expression (exp
);
1326 new = (struct display
*) xmalloc (sizeof (struct display
));
1329 new->block
= innermost_block
;
1330 new->next
= display_chain
;
1331 new->number
= ++display_number
;
1333 new->status
= enabled
;
1334 display_chain
= new;
1336 if (from_tty
&& target_has_execution
)
1337 do_one_display (new);
1350 /* Clear out the display_chain.
1351 Done when new symtabs are loaded, since this invalidates
1352 the types stored in many expressions. */
1357 register struct display
*d
;
1359 while ((d
= display_chain
) != NULL
)
1362 display_chain
= d
->next
;
1367 /* Delete the auto-display number NUM. */
1370 delete_display (num
)
1373 register struct display
*d1
, *d
;
1376 error ("No display number %d.", num
);
1378 if (display_chain
->number
== num
)
1381 display_chain
= d1
->next
;
1385 for (d
= display_chain
; ; d
= d
->next
)
1388 error ("No display number %d.", num
);
1389 if (d
->next
->number
== num
)
1399 /* Delete some values from the auto-display chain.
1400 Specify the element numbers. */
1403 undisplay_command (args
, from_tty
)
1407 register char *p
= args
;
1413 if (query ("Delete all auto-display expressions? "))
1422 while (*p1
>= '0' && *p1
<= '9') p1
++;
1423 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1424 error ("Arguments must be display numbers.");
1428 delete_display (num
);
1431 while (*p
== ' ' || *p
== '\t') p
++;
1436 /* Display a single auto-display.
1437 Do nothing if the display cannot be printed in the current context,
1438 or if the display is disabled. */
1444 int within_current_scope
;
1446 if (d
->status
== disabled
)
1450 within_current_scope
= contained_in (get_selected_block (), d
->block
);
1452 within_current_scope
= 1;
1453 if (!within_current_scope
)
1456 current_display_number
= d
->number
;
1458 annotate_display_begin ();
1459 printf_filtered ("%d", d
->number
);
1460 annotate_display_number_end ();
1461 printf_filtered (": ");
1467 annotate_display_format ();
1469 printf_filtered ("x/");
1470 if (d
->format
.count
!= 1)
1471 printf_filtered ("%d", d
->format
.count
);
1472 printf_filtered ("%c", d
->format
.format
);
1473 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1474 printf_filtered ("%c", d
->format
.size
);
1475 printf_filtered (" ");
1477 annotate_display_expression ();
1479 print_expression (d
->exp
, gdb_stdout
);
1480 annotate_display_expression_end ();
1482 if (d
->format
.count
!= 1)
1483 printf_filtered ("\n");
1485 printf_filtered (" ");
1487 val
= evaluate_expression (d
->exp
);
1488 addr
= value_as_pointer (val
);
1489 if (d
->format
.format
== 'i')
1490 addr
= ADDR_BITS_REMOVE (addr
);
1492 annotate_display_value ();
1494 do_examine (d
->format
, addr
, VALUE_BFD_SECTION (val
));
1498 annotate_display_format ();
1500 if (d
->format
.format
)
1501 printf_filtered ("/%c ", d
->format
.format
);
1503 annotate_display_expression ();
1505 print_expression (d
->exp
, gdb_stdout
);
1506 annotate_display_expression_end ();
1508 printf_filtered (" = ");
1510 annotate_display_expression ();
1512 print_formatted (evaluate_expression (d
->exp
),
1513 d
->format
.format
, d
->format
.size
);
1514 printf_filtered ("\n");
1517 annotate_display_end ();
1519 gdb_flush (gdb_stdout
);
1520 current_display_number
= -1;
1523 /* Display all of the values on the auto-display chain which can be
1524 evaluated in the current scope. */
1529 register struct display
*d
;
1531 for (d
= display_chain
; d
; d
= d
->next
)
1535 /* Delete the auto-display which we were in the process of displaying.
1536 This is done when there is an error or a signal. */
1539 disable_display (num
)
1542 register struct display
*d
;
1544 for (d
= display_chain
; d
; d
= d
->next
)
1545 if (d
->number
== num
)
1547 d
->status
= disabled
;
1550 printf_unfiltered ("No display number %d.\n", num
);
1554 disable_current_display ()
1556 if (current_display_number
>= 0)
1558 disable_display (current_display_number
);
1559 fprintf_unfiltered (gdb_stderr
, "Disabling display %d to avoid infinite recursion.\n",
1560 current_display_number
);
1562 current_display_number
= -1;
1566 display_info (ignore
, from_tty
)
1570 register struct display
*d
;
1573 printf_unfiltered ("There are no auto-display expressions now.\n");
1575 printf_filtered ("Auto-display expressions now in effect:\n\
1576 Num Enb Expression\n");
1578 for (d
= display_chain
; d
; d
= d
->next
)
1580 printf_filtered ("%d: %c ", d
->number
, "ny"[(int)d
->status
]);
1582 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
1584 else if (d
->format
.format
)
1585 printf_filtered ("/%c ", d
->format
.format
);
1586 print_expression (d
->exp
, gdb_stdout
);
1587 if (d
->block
&& !contained_in (get_selected_block (), d
->block
))
1588 printf_filtered (" (cannot be evaluated in the current context)");
1589 printf_filtered ("\n");
1590 gdb_flush (gdb_stdout
);
1595 enable_display (args
, from_tty
)
1599 register char *p
= args
;
1602 register struct display
*d
;
1606 for (d
= display_chain
; d
; d
= d
->next
)
1607 d
->status
= enabled
;
1613 while (*p1
>= '0' && *p1
<= '9')
1615 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1616 error ("Arguments must be display numbers.");
1620 for (d
= display_chain
; d
; d
= d
->next
)
1621 if (d
->number
== num
)
1623 d
->status
= enabled
;
1626 printf_unfiltered ("No display number %d.\n", num
);
1629 while (*p
== ' ' || *p
== '\t')
1636 disable_display_command (args
, from_tty
)
1640 register char *p
= args
;
1642 register struct display
*d
;
1646 for (d
= display_chain
; d
; d
= d
->next
)
1647 d
->status
= disabled
;
1653 while (*p1
>= '0' && *p1
<= '9')
1655 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1656 error ("Arguments must be display numbers.");
1658 disable_display (atoi (p
));
1661 while (*p
== ' ' || *p
== '\t')
1667 /* Print the value in stack frame FRAME of a variable
1668 specified by a struct symbol. */
1671 print_variable_value (var
, frame
, stream
)
1673 struct frame_info
*frame
;
1676 value_ptr val
= read_var_value (var
, frame
);
1678 value_print (val
, stream
, 0, Val_pretty_default
);
1681 /* Print the arguments of a stack frame, given the function FUNC
1682 running in that frame (as a symbol), the info on the frame,
1683 and the number of args according to the stack frame (or -1 if unknown). */
1685 /* References here and elsewhere to "number of args according to the
1686 stack frame" appear in all cases to refer to "number of ints of args
1687 according to the stack frame". At least for VAX, i386, isi. */
1690 print_frame_args (func
, fi
, num
, stream
)
1691 struct symbol
*func
;
1692 struct frame_info
*fi
;
1696 struct block
*b
= NULL
;
1700 register struct symbol
*sym
;
1701 register value_ptr val
;
1702 /* Offset of next stack argument beyond the one we have seen that is
1703 at the highest offset.
1704 -1 if we haven't come to a stack argument yet. */
1705 long highest_offset
= -1;
1707 /* Number of ints of arguments that we have printed so far. */
1708 int args_printed
= 0;
1712 b
= SYMBOL_BLOCK_VALUE (func
);
1713 nsyms
= BLOCK_NSYMS (b
);
1716 for (i
= 0; i
< nsyms
; i
++)
1719 sym
= BLOCK_SYM (b
, i
);
1721 /* Keep track of the highest stack argument offset seen, and
1722 skip over any kinds of symbols we don't care about. */
1724 switch (SYMBOL_CLASS (sym
)) {
1728 long current_offset
= SYMBOL_VALUE (sym
);
1729 arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
1731 /* Compute address of next argument by adding the size of
1732 this argument and rounding to an int boundary. */
1734 = ((current_offset
+ arg_size
+ sizeof (int) - 1)
1735 & ~(sizeof (int) - 1));
1737 /* If this is the highest offset seen yet, set highest_offset. */
1738 if (highest_offset
== -1
1739 || (current_offset
> highest_offset
))
1740 highest_offset
= current_offset
;
1742 /* Add the number of ints we're about to print to args_printed. */
1743 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
1746 /* We care about types of symbols, but don't need to keep track of
1747 stack offsets in them. */
1749 case LOC_REGPARM_ADDR
:
1751 case LOC_BASEREG_ARG
:
1754 /* Other types of symbols we just skip over. */
1759 /* We have to look up the symbol because arguments can have
1760 two entries (one a parameter, one a local) and the one we
1761 want is the local, which lookup_symbol will find for us.
1762 This includes gcc1 (not gcc2) on the sparc when passing a
1763 small structure and gcc2 when the argument type is float
1764 and it is passed as a double and converted to float by
1765 the prologue (in the latter case the type of the LOC_ARG
1766 symbol is double and the type of the LOC_LOCAL symbol is
1768 /* But if the parameter name is null, don't try it.
1769 Null parameter names occur on the RS/6000, for traceback tables.
1770 FIXME, should we even print them? */
1772 if (*SYMBOL_NAME (sym
))
1774 struct symbol
*nsym
;
1775 nsym
= lookup_symbol
1777 b
, VAR_NAMESPACE
, (int *)NULL
, (struct symtab
**)NULL
);
1778 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
)
1780 /* There is a LOC_ARG/LOC_REGISTER pair. This means that
1781 it was passed on the stack and loaded into a register,
1782 or passed in a register and stored in a stack slot.
1783 GDB 3.x used the LOC_ARG; GDB 4.0-4.11 used the LOC_REGISTER.
1785 Reasons for using the LOC_ARG:
1786 (1) because find_saved_registers may be slow for remote
1788 (2) because registers are often re-used and stack slots
1789 rarely (never?) are. Therefore using the stack slot is
1790 much less likely to print garbage.
1792 Reasons why we might want to use the LOC_REGISTER:
1793 (1) So that the backtrace prints the same value as
1794 "print foo". I see no compelling reason why this needs
1795 to be the case; having the backtrace print the value which
1796 was passed in, and "print foo" print the value as modified
1797 within the called function, makes perfect sense to me.
1799 Additional note: It might be nice if "info args" displayed
1801 One more note: There is a case with sparc structure passing
1802 where we need to use the LOC_REGISTER, but this is dealt with
1803 by creating a single LOC_REGPARM in symbol reading. */
1805 /* Leave sym (the LOC_ARG) alone. */
1812 /* Print the current arg. */
1814 fprintf_filtered (stream
, ", ");
1817 annotate_arg_begin ();
1819 fprintf_symbol_filtered (stream
, SYMBOL_SOURCE_NAME (sym
),
1820 SYMBOL_LANGUAGE (sym
), DMGL_PARAMS
| DMGL_ANSI
);
1821 annotate_arg_name_end ();
1822 fputs_filtered ("=", stream
);
1824 /* Avoid value_print because it will deref ref parameters. We just
1825 want to print their addresses. Print ??? for args whose address
1826 we do not know. We pass 2 as "recurse" to val_print because our
1827 standard indentation here is 4 spaces, and val_print indents
1828 2 for each recurse. */
1829 val
= read_var_value (sym
, fi
);
1831 annotate_arg_value (val
== NULL
? NULL
: VALUE_TYPE (val
));
1835 #ifdef GDB_TARGET_IS_D10V
1836 if (SYMBOL_CLASS(sym
) == LOC_REGPARM
&& TYPE_CODE(VALUE_TYPE(val
)) == TYPE_CODE_PTR
)
1837 TYPE_LENGTH(VALUE_TYPE(val
)) = 2;
1839 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
), VALUE_ADDRESS (val
),
1840 stream
, 0, 0, 2, Val_no_prettyprint
);
1843 fputs_filtered ("???", stream
);
1845 annotate_arg_end ();
1850 /* Don't print nameless args in situations where we don't know
1851 enough about the stack to find them. */
1856 if (highest_offset
== -1)
1857 start
= FRAME_ARGS_SKIP
;
1859 start
= highest_offset
;
1861 print_frame_nameless_args (fi
, start
, num
- args_printed
,
1866 /* Print nameless args on STREAM.
1867 FI is the frameinfo for this frame, START is the offset
1868 of the first nameless arg, and NUM is the number of nameless args to
1869 print. FIRST is nonzero if this is the first argument (not just
1870 the first nameless arg). */
1873 print_frame_nameless_args (fi
, start
, num
, first
, stream
)
1874 struct frame_info
*fi
;
1884 for (i
= 0; i
< num
; i
++)
1887 #ifdef NAMELESS_ARG_VALUE
1888 NAMELESS_ARG_VALUE (fi
, start
, &arg_value
);
1890 argsaddr
= FRAME_ARGS_ADDRESS (fi
);
1894 arg_value
= read_memory_integer (argsaddr
+ start
, sizeof (int));
1898 fprintf_filtered (stream
, ", ");
1900 #ifdef PRINT_NAMELESS_INTEGER
1901 PRINT_NAMELESS_INTEGER (stream
, arg_value
);
1903 #ifdef PRINT_TYPELESS_INTEGER
1904 PRINT_TYPELESS_INTEGER (stream
, builtin_type_int
, (LONGEST
) arg_value
);
1906 fprintf_filtered (stream
, "%ld", arg_value
);
1907 #endif /* PRINT_TYPELESS_INTEGER */
1908 #endif /* PRINT_NAMELESS_INTEGER */
1910 start
+= sizeof (int);
1916 printf_command (arg
, from_tty
)
1921 register char *s
= arg
;
1923 value_ptr
*val_args
;
1925 char *current_substring
;
1927 int allocated_args
= 20;
1928 struct cleanup
*old_cleanups
;
1930 val_args
= (value_ptr
*) xmalloc (allocated_args
* sizeof (value_ptr
));
1931 old_cleanups
= make_cleanup (free_current_contents
, &val_args
);
1934 error_no_arg ("format-control string and values to print");
1936 /* Skip white space before format string */
1937 while (*s
== ' ' || *s
== '\t') s
++;
1939 /* A format string should follow, enveloped in double quotes */
1941 error ("Bad format string, missing '\"'.");
1943 /* Parse the format-control string and copy it into the string STRING,
1944 processing some kinds of escape sequence. */
1946 f
= string
= (char *) alloca (strlen (s
) + 1);
1954 error ("Bad format string, non-terminated '\"'.");
1966 *f
++ = '\007'; /* Bell */
1991 /* ??? TODO: handle other escape sequences */
1992 error ("Unrecognized escape character \\%c in format string.",
2002 /* Skip over " and following space and comma. */
2005 while (*s
== ' ' || *s
== '\t') s
++;
2007 if (*s
!= ',' && *s
!= 0)
2008 error ("Invalid argument syntax");
2011 while (*s
== ' ' || *s
== '\t') s
++;
2013 /* Need extra space for the '\0's. Doubling the size is sufficient. */
2014 substrings
= alloca (strlen (string
) * 2);
2015 current_substring
= substrings
;
2018 /* Now scan the string for %-specs and see what kinds of args they want.
2019 argclass[I] classifies the %-specs so we can give printf_filtered
2020 something of the right size. */
2022 enum argclass
{no_arg
, int_arg
, string_arg
, double_arg
, long_long_arg
};
2023 enum argclass
*argclass
;
2024 enum argclass this_argclass
;
2030 argclass
= (enum argclass
*) alloca (strlen (s
) * sizeof *argclass
);
2038 while (strchr ("0123456789.hlL-+ #", *f
))
2040 if (*f
== 'l' || *f
== 'L')
2047 this_argclass
= string_arg
;
2053 this_argclass
= double_arg
;
2057 error ("`*' not supported for precision or width in printf");
2060 error ("Format specifier `n' not supported in printf");
2063 this_argclass
= no_arg
;
2068 this_argclass
= long_long_arg
;
2070 this_argclass
= int_arg
;
2074 if (this_argclass
!= no_arg
)
2076 strncpy (current_substring
, last_arg
, f
- last_arg
);
2077 current_substring
+= f
- last_arg
;
2078 *current_substring
++ = '\0';
2080 argclass
[nargs_wanted
++] = this_argclass
;
2084 /* Now, parse all arguments and evaluate them.
2085 Store the VALUEs in VAL_ARGS. */
2090 if (nargs
== allocated_args
)
2091 val_args
= (value_ptr
*) xrealloc ((char *) val_args
,
2092 (allocated_args
*= 2)
2093 * sizeof (value_ptr
));
2095 val_args
[nargs
] = parse_to_comma_and_eval (&s1
);
2097 /* If format string wants a float, unchecked-convert the value to
2098 floating point of the same size */
2100 if (argclass
[nargs
] == double_arg
)
2102 struct type
*type
= VALUE_TYPE (val_args
[nargs
]);
2103 if (TYPE_LENGTH (type
) == sizeof (float))
2104 VALUE_TYPE (val_args
[nargs
]) = builtin_type_float
;
2105 if (TYPE_LENGTH (type
) == sizeof (double))
2106 VALUE_TYPE (val_args
[nargs
]) = builtin_type_double
;
2114 if (nargs
!= nargs_wanted
)
2115 error ("Wrong number of arguments for specified format-string");
2117 /* Now actually print them. */
2118 current_substring
= substrings
;
2119 for (i
= 0; i
< nargs
; i
++)
2121 switch (argclass
[i
])
2128 tem
= value_as_pointer (val_args
[i
]);
2130 /* This is a %s argument. Find the length of the string. */
2135 read_memory_section (tem
+ j
, &c
, 1,
2136 VALUE_BFD_SECTION (val_args
[i
]));
2141 /* Copy the string contents into a string inside GDB. */
2142 str
= (char *) alloca (j
+ 1);
2143 read_memory_section (tem
, str
, j
, VALUE_BFD_SECTION (val_args
[i
]));
2146 printf_filtered (current_substring
, str
);
2151 double val
= value_as_double (val_args
[i
]);
2152 printf_filtered (current_substring
, val
);
2156 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2158 long long val
= value_as_long (val_args
[i
]);
2159 printf_filtered (current_substring
, val
);
2163 error ("long long not supported in printf");
2167 /* FIXME: there should be separate int_arg and long_arg. */
2168 long val
= value_as_long (val_args
[i
]);
2169 printf_filtered (current_substring
, val
);
2173 error ("internal error in printf_command");
2175 /* Skip to the next substring. */
2176 current_substring
+= strlen (current_substring
) + 1;
2178 /* Print the portion of the format string after the last argument. */
2179 printf_filtered (last_arg
);
2181 do_cleanups (old_cleanups
);
2184 /* Dump a specified section of assembly code. With no command line
2185 arguments, this command will dump the assembly code for the
2186 function surrounding the pc value in the selected frame. With one
2187 argument, it will dump the assembly code surrounding that pc value.
2188 Two arguments are interpeted as bounds within which to dump
2193 disassemble_command (arg
, from_tty
)
2197 CORE_ADDR low
, high
;
2199 CORE_ADDR pc
, pc_masked
;
2206 if (!selected_frame
)
2207 error ("No frame selected.\n");
2209 pc
= get_frame_pc (selected_frame
);
2210 if (find_pc_partial_function (pc
, &name
, &low
, &high
) == 0)
2211 error ("No function contains program counter for selected frame.\n");
2212 low
+= FUNCTION_START_OFFSET
;
2214 else if (!(space_index
= (char *) strchr (arg
, ' ')))
2217 pc
= parse_and_eval_address (arg
);
2218 if (find_pc_partial_function (pc
, &name
, &low
, &high
) == 0)
2219 error ("No function contains specified address.\n");
2220 low
+= FUNCTION_START_OFFSET
;
2224 /* Two arguments. */
2225 *space_index
= '\0';
2226 low
= parse_and_eval_address (arg
);
2227 high
= parse_and_eval_address (space_index
+ 1);
2230 printf_filtered ("Dump of assembler code ");
2233 printf_filtered ("for function %s:\n", name
);
2237 printf_filtered ("from ");
2238 print_address_numeric (low
, 1, gdb_stdout
);
2239 printf_filtered (" to ");
2240 print_address_numeric (high
, 1, gdb_stdout
);
2241 printf_filtered (":\n");
2244 /* Dump the specified range. */
2247 #ifdef GDB_TARGET_MASK_DISAS_PC
2248 pc_masked
= GDB_TARGET_MASK_DISAS_PC (pc
);
2253 while (pc_masked
< high
)
2256 print_address (pc_masked
, gdb_stdout
);
2257 printf_filtered (":\t");
2258 /* We often wrap here if there are long symbolic names. */
2260 pc
+= print_insn (pc
, gdb_stdout
);
2261 printf_filtered ("\n");
2263 #ifdef GDB_TARGET_MASK_DISAS_PC
2264 pc_masked
= GDB_TARGET_MASK_DISAS_PC (pc
);
2269 printf_filtered ("End of assembler dump.\n");
2270 gdb_flush (gdb_stdout
);
2273 /* Print the instruction at address MEMADDR in debugged memory,
2274 on STREAM. Returns length of the instruction, in bytes. */
2277 print_insn (memaddr
, stream
)
2281 /* If there's no disassembler, something is very wrong. */
2282 if (tm_print_insn
== NULL
)
2285 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
2286 tm_print_insn_info
.endian
= BFD_ENDIAN_BIG
;
2288 tm_print_insn_info
.endian
= BFD_ENDIAN_LITTLE
;
2290 if (target_architecture
!= NULL
)
2291 tm_print_insn_info
.mach
= target_architecture
->mach
;
2292 /* else: should set .mach=0 but some disassemblers don't grok this */
2294 return (*tm_print_insn
) (memaddr
, &tm_print_insn_info
);
2299 _initialize_printcmd ()
2301 current_display_number
= -1;
2303 add_info ("address", address_info
,
2304 "Describe where symbol SYM is stored.");
2306 add_info ("symbol", sym_info
,
2307 "Describe what symbol is at location ADDR.\n\
2308 Only for symbols with fixed locations (global or static scope).");
2310 add_com ("x", class_vars
, x_command
,
2311 concat ("Examine memory: x/FMT ADDRESS.\n\
2312 ADDRESS is an expression for the memory address to examine.\n\
2313 FMT is a repeat count followed by a format letter and a size letter.\n\
2314 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2315 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n",
2316 "Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2317 The specified number of objects of the specified size are printed\n\
2318 according to the format.\n\n\
2319 Defaults for format and size letters are those previously used.\n\
2320 Default count is 1. Default address is following last thing printed\n\
2321 with this command or \"print\".", NULL
));
2323 add_com ("disassemble", class_vars
, disassemble_command
,
2324 "Disassemble a specified section of memory.\n\
2325 Default is the function surrounding the pc of the selected frame.\n\
2326 With a single argument, the function surrounding that address is dumped.\n\
2327 Two arguments are taken as a range of memory to dump.");
2330 add_com ("whereis", class_vars
, whereis_command
,
2331 "Print line number and file of definition of variable.");
2334 add_info ("display", display_info
,
2335 "Expressions to display when program stops, with code numbers.");
2337 add_cmd ("undisplay", class_vars
, undisplay_command
,
2338 "Cancel some expressions to be displayed when program stops.\n\
2339 Arguments are the code numbers of the expressions to stop displaying.\n\
2340 No argument means cancel all automatic-display expressions.\n\
2341 \"delete display\" has the same effect as this command.\n\
2342 Do \"info display\" to see current list of code numbers.",
2345 add_com ("display", class_vars
, display_command
,
2346 "Print value of expression EXP each time the program stops.\n\
2347 /FMT may be used before EXP as in the \"print\" command.\n\
2348 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2349 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2350 and examining is done as in the \"x\" command.\n\n\
2351 With no argument, display all currently requested auto-display expressions.\n\
2352 Use \"undisplay\" to cancel display requests previously made."
2355 add_cmd ("display", class_vars
, enable_display
,
2356 "Enable some expressions to be displayed when program stops.\n\
2357 Arguments are the code numbers of the expressions to resume displaying.\n\
2358 No argument means enable all automatic-display expressions.\n\
2359 Do \"info display\" to see current list of code numbers.", &enablelist
);
2361 add_cmd ("display", class_vars
, disable_display_command
,
2362 "Disable some expressions to be displayed when program stops.\n\
2363 Arguments are the code numbers of the expressions to stop displaying.\n\
2364 No argument means disable all automatic-display expressions.\n\
2365 Do \"info display\" to see current list of code numbers.", &disablelist
);
2367 add_cmd ("display", class_vars
, undisplay_command
,
2368 "Cancel some expressions to be displayed when program stops.\n\
2369 Arguments are the code numbers of the expressions to stop displaying.\n\
2370 No argument means cancel all automatic-display expressions.\n\
2371 Do \"info display\" to see current list of code numbers.", &deletelist
);
2373 add_com ("printf", class_vars
, printf_command
,
2374 "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2375 This is useful for formatted output in user-defined commands.");
2377 add_com ("output", class_vars
, output_command
,
2378 "Like \"print\" but don't put in value history and don't print newline.\n\
2379 This is useful in user-defined commands.");
2381 add_prefix_cmd ("set", class_vars
, set_command
,
2382 concat ("Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2383 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2384 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2385 with $), a register (a few standard names starting with $), or an actual\n\
2386 variable in the program being debugged. EXP is any valid expression.\n",
2387 "Use \"set variable\" for variables with names identical to set subcommands.\n\
2388 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2389 You can see these environment settings with the \"show\" command.", NULL
),
2390 &setlist
, "set ", 1, &cmdlist
);
2392 /* "call" is the same as "set", but handy for dbx users to call fns. */
2393 add_com ("call", class_vars
, call_command
,
2394 "Call a function in the program.\n\
2395 The argument is the function name and arguments, in the notation of the\n\
2396 current working language. The result is printed and saved in the value\n\
2397 history, if it is not void.");
2399 add_cmd ("variable", class_vars
, set_command
,
2400 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2401 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2402 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2403 with $), a register (a few standard names starting with $), or an actual\n\
2404 variable in the program being debugged. EXP is any valid expression.\n\
2405 This may usually be abbreviated to simply \"set\".",
2408 add_com ("print", class_vars
, print_command
,
2409 concat ("Print value of expression EXP.\n\
2410 Variables accessible are those of the lexical environment of the selected\n\
2411 stack frame, plus all those whose scope is global or an entire file.\n\
2413 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2414 $$NUM refers to NUM'th value back from the last one.\n\
2415 Names starting with $ refer to registers (with the values they would have\n",
2416 "if the program were to return to the stack frame now selected, restoring\n\
2417 all registers saved by frames farther in) or else to debugger\n\
2418 \"convenience\" variables (any such name not a known register).\n\
2419 Use assignment expressions to give values to convenience variables.\n",
2421 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2422 @ is a binary operator for treating consecutive data objects\n\
2423 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2424 element is FOO, whose second element is stored in the space following\n\
2425 where FOO is stored, etc. FOO must be an expression whose value\n\
2426 resides in memory.\n",
2428 EXP may be preceded with /FMT, where FMT is a format letter\n\
2429 but no count or size letter (see \"x\" command).", NULL
));
2430 add_com_alias ("p", "print", class_vars
, 1);
2432 add_com ("inspect", class_vars
, inspect_command
,
2433 "Same as \"print\" command, except that if you are running in the epoch\n\
2434 environment, the value is printed in its own window.");
2437 add_set_cmd ("max-symbolic-offset", no_class
, var_uinteger
,
2438 (char *)&max_symbolic_offset
,
2439 "Set the largest offset that will be printed in <symbol+1234> form.",
2443 add_set_cmd ("symbol-filename", no_class
, var_boolean
,
2444 (char *)&print_symbol_filename
,
2445 "Set printing of source filename and line number with <symbol>.",
2449 /* For examine/instruction a single byte quantity is specified as
2450 the data. This avoids problems with value_at_lazy() requiring a
2451 valid data type (and rejecting VOID). */
2452 examine_i_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_i_type", NULL
);
2454 examine_b_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_b_type", NULL
);
2455 examine_h_type
= init_type (TYPE_CODE_INT
, 2, 0, "examine_h_type", NULL
);
2456 examine_w_type
= init_type (TYPE_CODE_INT
, 4, 0, "examine_w_type", NULL
);
2457 examine_g_type
= init_type (TYPE_CODE_INT
, 8, 0, "examine_g_type", NULL
);
2459 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info
, gdb_stdout
, (fprintf_ftype
)fprintf_filtered
);
2460 tm_print_insn_info
.flavour
= bfd_target_unknown_flavour
;
2461 tm_print_insn_info
.read_memory_func
= dis_asm_read_memory
;
2462 tm_print_insn_info
.memory_error_func
= dis_asm_memory_error
;
2463 tm_print_insn_info
.print_address_func
= dis_asm_print_address
;