1 /* Print values for GNU debugger GDB.
2 Copyright 1986, 87, 88, 89, 90, 91, 93, 94, 95, 1998
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
*));
178 static void sym_info
PARAMS ((char *, int));
181 /* Decode a format specification. *STRING_PTR should point to it.
182 OFORMAT and OSIZE are used as defaults for the format and size
183 if none are given in the format specification.
184 If OSIZE is zero, then the size field of the returned value
185 should be set only if a size is explicitly specified by the
187 The structure returned describes all the data
188 found in the specification. In addition, *STRING_PTR is advanced
189 past the specification and past all whitespace following it. */
191 static struct format_data
192 decode_format (string_ptr
, oformat
, osize
)
197 struct format_data val
;
198 register char *p
= *string_ptr
;
204 if (*p
>= '0' && *p
<= '9')
205 val
.count
= atoi (p
);
206 while (*p
>= '0' && *p
<= '9') p
++;
208 /* Now process size or format letters that follow. */
212 if (*p
== 'b' || *p
== 'h' || *p
== 'w' || *p
== 'g')
214 else if (*p
>= 'a' && *p
<= 'z')
220 while (*p
== ' ' || *p
== '\t') p
++;
223 /* Set defaults for format and size if not specified. */
224 if (val
.format
== '?')
228 /* Neither has been specified. */
229 val
.format
= oformat
;
233 /* If a size is specified, any format makes a reasonable
234 default except 'i'. */
235 val
.format
= oformat
== 'i' ? 'x' : oformat
;
237 else if (val
.size
== '?')
242 /* Pick the appropriate size for an address. */
243 if (TARGET_PTR_BIT
== 64)
244 val
.size
= osize
? 'g' : osize
;
245 else if (TARGET_PTR_BIT
== 32)
246 val
.size
= osize
? 'w' : osize
;
247 else if (TARGET_PTR_BIT
== 16)
248 val
.size
= osize
? 'h' : osize
;
250 /* Bad value for TARGET_PTR_BIT */
254 /* Floating point has to be word or giantword. */
255 if (osize
== 'w' || osize
== 'g')
258 /* Default it to giantword if the last used size is not
260 val
.size
= osize
? 'g' : osize
;
263 /* Characters default to one byte. */
264 val
.size
= osize
? 'b' : osize
;
267 /* The default is the size most recently specified. */
274 /* Print value VAL on gdb_stdout according to FORMAT, a letter or 0.
275 Do not end with a newline.
276 0 means print VAL according to its own type.
277 SIZE is the letter for the size of datum being printed.
278 This is used to pad hex numbers so they line up. */
281 print_formatted (val
, format
, size
)
282 register value_ptr val
;
286 struct type
*type
= check_typedef (VALUE_TYPE (val
));
287 int len
= TYPE_LENGTH (type
);
289 if (VALUE_LVAL (val
) == lval_memory
)
291 next_address
= VALUE_ADDRESS (val
) + len
;
292 next_section
= VALUE_BFD_SECTION (val
);
298 /* FIXME: Need to handle wchar_t's here... */
299 next_address
= VALUE_ADDRESS (val
)
300 + val_print_string (VALUE_ADDRESS (val
), -1, 1, gdb_stdout
);
301 next_section
= VALUE_BFD_SECTION (val
);
305 /* The old comment says
306 "Force output out, print_insn not using _filtered".
307 I'm not completely sure what that means, I suspect most print_insn
308 now do use _filtered, so I guess it's obsolete. */
309 /* We often wrap here if there are long symbolic names. */
311 next_address
= VALUE_ADDRESS (val
)
312 + print_insn (VALUE_ADDRESS (val
), gdb_stdout
);
313 next_section
= VALUE_BFD_SECTION (val
);
318 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
319 || TYPE_CODE (type
) == TYPE_CODE_STRING
320 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
321 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
322 value_print (val
, gdb_stdout
, format
, Val_pretty_default
);
324 print_scalar_formatted (VALUE_CONTENTS (val
), type
,
325 format
, size
, gdb_stdout
);
329 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
330 according to letters FORMAT and SIZE on STREAM.
331 FORMAT may not be zero. Formats s and i are not supported at this level.
333 This is how the elements of an array or structure are printed
337 print_scalar_formatted (valaddr
, type
, format
, size
, stream
)
345 unsigned int len
= TYPE_LENGTH (type
);
347 if (len
> sizeof (LONGEST
)
355 if (! TYPE_UNSIGNED (type
)
356 || ! extract_long_unsigned_integer (valaddr
, len
, &val_long
))
358 /* We can't print it normally, but we can print it in hex.
359 Printing it in the wrong radix is more useful than saying
360 "use /x, you dummy". */
361 /* FIXME: we could also do octal or binary if that was the
363 /* FIXME: we should be using the size field to give us a
364 minimum field width to print. */
365 val_print_type_code_int (type
, valaddr
, stream
);
369 /* If we get here, extract_long_unsigned_integer set val_long. */
371 else if (format
!= 'f')
372 val_long
= unpack_long (type
, valaddr
);
374 /* If we are printing it as unsigned, truncate it in case it is actually
375 a negative signed value (e.g. "print/u (short)-1" should print 65535
376 (if shorts are 16 bits) instead of 4294967295). */
379 if (len
< sizeof (LONGEST
))
380 val_long
&= ((LONGEST
) 1 << HOST_CHAR_BIT
* len
) - 1;
388 /* no size specified, like in print. Print varying # of digits. */
389 print_longest (stream
, 'x', 1, val_long
);
398 print_longest (stream
, size
, 1, val_long
);
401 error ("Undefined output size \"%c\".", size
);
406 print_longest (stream
, 'd', 1, val_long
);
410 print_longest (stream
, 'u', 0, val_long
);
415 print_longest (stream
, 'o', 1, val_long
);
417 fprintf_filtered (stream
, "0");
421 print_address (unpack_pointer (type
, valaddr
), stream
);
425 value_print (value_from_longest (builtin_type_char
, val_long
), stream
, 0,
430 if (len
== sizeof (float))
431 type
= builtin_type_float
;
432 else if (len
== sizeof (double))
433 type
= builtin_type_double
;
434 print_floating (valaddr
, type
, stream
);
441 /* Binary; 't' stands for "two". */
443 char bits
[8*(sizeof val_long
) + 1];
448 width
= 8*(sizeof val_long
);
465 error ("Undefined output size \"%c\".", size
);
471 bits
[width
] = (val_long
& 1) ? '1' : '0';
476 while (*cp
&& *cp
== '0')
481 fprintf_filtered (stream
, local_binary_format_prefix());
482 fprintf_filtered (stream
, cp
);
483 fprintf_filtered (stream
, local_binary_format_suffix());
488 error ("Undefined output format \"%c\".", format
);
492 /* Specify default address for `x' command.
493 `info lines' uses this. */
496 set_next_address (addr
)
501 /* Make address available to the user as $_. */
502 set_internalvar (lookup_internalvar ("_"),
503 value_from_longest (lookup_pointer_type (builtin_type_void
),
507 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
508 after LEADIN. Print nothing if no symbolic name is found nearby.
509 Optionally also print source file and line number, if available.
510 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
511 or to interpret it as a possible C++ name and convert it back to source
512 form. However note that DO_DEMANGLE can be overridden by the specific
513 settings of the demangle and asm_demangle variables. */
516 print_address_symbolic (addr
, stream
, do_demangle
, leadin
)
522 struct minimal_symbol
*msymbol
;
523 struct symbol
*symbol
;
524 struct symtab
*symtab
= 0;
525 CORE_ADDR name_location
= 0;
527 asection
*section
= 0;
530 /* Determine if the address is in an overlay, and whether it is mapped. */
531 if (overlay_debugging
)
533 section
= find_pc_overlay (addr
);
534 if (pc_in_unmapped_range (addr
, section
))
537 addr
= overlay_mapped_address (addr
, section
);
541 /* On some targets, add in extra "flag" bits to PC for
542 disassembly. This should ensure that "rounding errors" in
543 symbol addresses that are masked for disassembly favour the
544 the correct symbol. */
546 #ifdef GDB_TARGET_UNMASK_DISAS_PC
547 addr
= GDB_TARGET_UNMASK_DISAS_PC (addr
);
550 /* First try to find the address in the symbol table, then
551 in the minsyms. Take the closest one. */
553 /* This is defective in the sense that it only finds text symbols. So
554 really this is kind of pointless--we should make sure that the
555 minimal symbols have everything we need (by changing that we could
556 save some memory, but for many debug format--ELF/DWARF or
557 anything/stabs--it would be inconvenient to eliminate those minimal
559 msymbol
= lookup_minimal_symbol_by_pc_section (addr
, section
);
560 symbol
= find_pc_sect_function (addr
, section
);
564 name_location
= BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
));
566 name
= SYMBOL_SOURCE_NAME (symbol
);
568 name
= SYMBOL_LINKAGE_NAME (symbol
);
573 if (SYMBOL_VALUE_ADDRESS (msymbol
) > name_location
|| symbol
== NULL
)
575 /* The msymbol is closer to the address than the symbol;
576 use the msymbol instead. */
579 name_location
= SYMBOL_VALUE_ADDRESS (msymbol
);
581 name
= SYMBOL_SOURCE_NAME (msymbol
);
583 name
= SYMBOL_LINKAGE_NAME (msymbol
);
586 if (symbol
== NULL
&& msymbol
== NULL
)
589 /* On some targets, mask out extra "flag" bits from PC for handsome
592 #ifdef GDB_TARGET_MASK_DISAS_PC
593 name_location
= GDB_TARGET_MASK_DISAS_PC (name_location
);
594 addr
= GDB_TARGET_MASK_DISAS_PC (addr
);
597 /* If the nearest symbol is too far away, don't print anything symbolic. */
599 /* For when CORE_ADDR is larger than unsigned int, we do math in
600 CORE_ADDR. But when we detect unsigned wraparound in the
601 CORE_ADDR math, we ignore this test and print the offset,
602 because addr+max_symbolic_offset has wrapped through the end
603 of the address space back to the beginning, giving bogus comparison. */
604 if (addr
> name_location
+ max_symbolic_offset
605 && name_location
+ max_symbolic_offset
> name_location
)
608 fputs_filtered (leadin
, stream
);
610 fputs_filtered ("<*", stream
);
612 fputs_filtered ("<", stream
);
613 fputs_filtered (name
, stream
);
614 if (addr
!= name_location
)
615 fprintf_filtered (stream
, "+%u", (unsigned int)(addr
- name_location
));
617 /* Append source filename and line number if desired. Give specific
618 line # of this addr, if we have it; else line # of the nearest symbol. */
619 if (print_symbol_filename
)
621 struct symtab_and_line sal
;
623 sal
= find_pc_sect_line (addr
, section
, 0);
626 fprintf_filtered (stream
, " at %s:%d", sal
.symtab
->filename
, sal
.line
);
627 else if (symtab
&& symbol
&& symbol
->line
)
628 fprintf_filtered (stream
, " at %s:%d", symtab
->filename
, symbol
->line
);
630 fprintf_filtered (stream
, " in %s", symtab
->filename
);
633 fputs_filtered ("*>", stream
);
635 fputs_filtered (">", stream
);
638 /* Print address ADDR on STREAM. USE_LOCAL means the same thing as for
641 print_address_numeric (addr
, use_local
, stream
)
646 /* This assumes a CORE_ADDR can fit in a LONGEST. Probably a safe
648 print_longest (stream
, 'x', use_local
, (ULONGEST
) addr
);
651 /* Print address ADDR symbolically on STREAM.
652 First print it as a number. Then perhaps print
653 <SYMBOL + OFFSET> after the number. */
656 print_address (addr
, stream
)
660 print_address_numeric (addr
, 1, stream
);
661 print_address_symbolic (addr
, stream
, asm_demangle
, " ");
664 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
665 controls whether to print the symbolic name "raw" or demangled.
666 Global setting "addressprint" controls whether to print hex address
670 print_address_demangle (addr
, stream
, do_demangle
)
677 fprintf_filtered (stream
, "0");
679 else if (addressprint
)
681 print_address_numeric (addr
, 1, stream
);
682 print_address_symbolic (addr
, stream
, do_demangle
, " ");
686 print_address_symbolic (addr
, stream
, do_demangle
, "");
691 /* These are the types that $__ will get after an examine command of one
694 static struct type
*examine_i_type
;
696 static struct type
*examine_b_type
;
697 static struct type
*examine_h_type
;
698 static struct type
*examine_w_type
;
699 static struct type
*examine_g_type
;
701 /* Examine data at address ADDR in format FMT.
702 Fetch it from memory and print on gdb_stdout. */
705 do_examine (fmt
, addr
, sect
)
706 struct format_data fmt
;
710 register char format
= 0;
712 register int count
= 1;
713 struct type
*val_type
= NULL
;
715 register int maxelts
;
723 /* String or instruction format implies fetch single bytes
724 regardless of the specified size. */
725 if (format
== 's' || format
== 'i')
729 val_type
= examine_i_type
;
730 else if (size
== 'b')
731 val_type
= examine_b_type
;
732 else if (size
== 'h')
733 val_type
= examine_h_type
;
734 else if (size
== 'w')
735 val_type
= examine_w_type
;
736 else if (size
== 'g')
737 val_type
= examine_g_type
;
744 if (format
== 's' || format
== 'i')
747 /* Print as many objects as specified in COUNT, at most maxelts per line,
748 with the address of the next one at the start of each line. */
753 print_address (next_address
, gdb_stdout
);
754 printf_filtered (":");
759 printf_filtered ("\t");
760 /* Note that print_formatted sets next_address for the next
762 last_examine_address
= next_address
;
763 /* The value to be displayed is not fetched greedily.
764 Instead, to avoid the posibility of a fetched value not
765 being used, its retreval is delayed until the print code
766 uses it. When examining an instruction stream, the
767 disassembler will perform its own memory fetch using just
768 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
769 the disassembler be modified so that LAST_EXAMINE_VALUE
770 is left with the byte sequence from the last complete
771 instruction fetched from memory? */
772 last_examine_value
= value_at_lazy (val_type
, next_address
, sect
);
773 print_formatted (last_examine_value
, format
, size
);
775 printf_filtered ("\n");
776 gdb_flush (gdb_stdout
);
781 validate_format (fmt
, cmdname
)
782 struct format_data fmt
;
786 error ("Size letters are meaningless in \"%s\" command.", cmdname
);
788 error ("Item count other than 1 is meaningless in \"%s\" command.",
790 if (fmt
.format
== 'i' || fmt
.format
== 's')
791 error ("Format letter \"%c\" is meaningless in \"%s\" command.",
792 fmt
.format
, cmdname
);
795 /* Evaluate string EXP as an expression in the current language and
796 print the resulting value. EXP may contain a format specifier as the
797 first argument ("/x myvar" for example, to print myvar in hex).
801 print_command_1 (exp
, inspect
, voidprint
)
806 struct expression
*expr
;
807 register struct cleanup
*old_chain
= 0;
808 register char format
= 0;
809 register value_ptr val
;
810 struct format_data fmt
;
813 /* Pass inspect flag to the rest of the print routines in a global (sigh). */
814 inspect_it
= inspect
;
816 if (exp
&& *exp
== '/')
819 fmt
= decode_format (&exp
, last_format
, 0);
820 validate_format (fmt
, "print");
821 last_format
= format
= fmt
.format
;
832 extern int objectprint
;
834 expr
= parse_expression (exp
);
835 old_chain
= make_cleanup ((make_cleanup_func
) free_current_contents
,
838 val
= evaluate_expression (expr
);
840 /* C++: figure out what type we actually want to print it as. */
841 type
= VALUE_TYPE (val
);
844 && ( TYPE_CODE (type
) == TYPE_CODE_PTR
845 || TYPE_CODE (type
) == TYPE_CODE_REF
)
846 && ( TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
847 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_UNION
))
851 v
= value_from_vtable_info (val
, TYPE_TARGET_TYPE (type
));
855 type
= VALUE_TYPE (val
);
860 val
= access_value_history (0);
862 if (voidprint
|| (val
&& VALUE_TYPE (val
) &&
863 TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_VOID
))
865 int histindex
= record_latest_value (val
);
868 annotate_value_history_begin (histindex
, VALUE_TYPE (val
));
870 annotate_value_begin (VALUE_TYPE (val
));
873 printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"", exp
, histindex
);
875 if (histindex
>= 0) printf_filtered ("$%d = ", histindex
);
878 annotate_value_history_value ();
880 print_formatted (val
, format
, fmt
.size
);
881 printf_filtered ("\n");
884 annotate_value_history_end ();
886 annotate_value_end ();
889 printf_unfiltered("\") )\030");
893 do_cleanups (old_chain
);
894 inspect_it
= 0; /* Reset print routines to normal */
899 print_command (exp
, from_tty
)
903 print_command_1 (exp
, 0, 1);
906 /* Same as print, except in epoch, it gets its own window */
909 inspect_command (exp
, from_tty
)
913 extern int epoch_interface
;
915 print_command_1 (exp
, epoch_interface
, 1);
918 /* Same as print, except it doesn't print void results. */
921 call_command (exp
, from_tty
)
925 print_command_1 (exp
, 0, 0);
930 output_command (exp
, from_tty
)
934 struct expression
*expr
;
935 register struct cleanup
*old_chain
;
936 register char format
= 0;
937 register value_ptr val
;
938 struct format_data fmt
;
940 if (exp
&& *exp
== '/')
943 fmt
= decode_format (&exp
, 0, 0);
944 validate_format (fmt
, "output");
948 expr
= parse_expression (exp
);
949 old_chain
= make_cleanup ((make_cleanup_func
) free_current_contents
, &expr
);
951 val
= evaluate_expression (expr
);
953 annotate_value_begin (VALUE_TYPE (val
));
955 print_formatted (val
, format
, fmt
.size
);
957 annotate_value_end ();
959 do_cleanups (old_chain
);
964 set_command (exp
, from_tty
)
968 struct expression
*expr
= parse_expression (exp
);
969 register struct cleanup
*old_chain
970 = make_cleanup ((make_cleanup_func
) free_current_contents
, &expr
);
971 evaluate_expression (expr
);
972 do_cleanups (old_chain
);
977 sym_info (arg
, 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 sect
= osect
->the_bfd_section
;
996 sect_addr
= overlay_mapped_address (addr
, sect
);
998 if (osect
->addr
<= sect_addr
&& sect_addr
< osect
->endaddr
&&
999 (msymbol
= lookup_minimal_symbol_by_pc_section (sect_addr
, sect
)))
1002 offset
= sect_addr
- SYMBOL_VALUE_ADDRESS (msymbol
);
1004 printf_filtered ("%s + %u in ",
1005 SYMBOL_SOURCE_NAME (msymbol
), offset
);
1007 printf_filtered ("%s in ",
1008 SYMBOL_SOURCE_NAME (msymbol
));
1009 if (pc_in_unmapped_range (addr
, sect
))
1010 printf_filtered ("load address range of ");
1011 if (section_is_overlay (sect
))
1012 printf_filtered ("%s overlay ",
1013 section_is_mapped (sect
) ? "mapped" : "unmapped");
1014 printf_filtered ("section %s", sect
->name
);
1015 printf_filtered ("\n");
1019 printf_filtered ("No symbol matches %s.\n", arg
);
1024 address_info (exp
, from_tty
)
1028 register struct symbol
*sym
;
1029 register struct minimal_symbol
*msymbol
;
1031 register long basereg
;
1033 CORE_ADDR load_addr
;
1034 int is_a_field_of_this
; /* C++: lookup_symbol sets this to nonzero
1035 if exp is a field of `this'. */
1038 error ("Argument required.");
1040 sym
= lookup_symbol (exp
, get_selected_block (), VAR_NAMESPACE
,
1041 &is_a_field_of_this
, (struct symtab
**)NULL
);
1044 if (is_a_field_of_this
)
1046 printf_filtered ("Symbol \"");
1047 fprintf_symbol_filtered (gdb_stdout
, exp
,
1048 current_language
->la_language
, DMGL_ANSI
);
1049 printf_filtered ("\" is a field of the local class variable `this'\n");
1053 msymbol
= lookup_minimal_symbol (exp
, NULL
, NULL
);
1055 if (msymbol
!= NULL
)
1057 load_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1059 printf_filtered ("Symbol \"");
1060 fprintf_symbol_filtered (gdb_stdout
, exp
,
1061 current_language
->la_language
, DMGL_ANSI
);
1062 printf_filtered ("\" is at ");
1063 print_address_numeric (load_addr
, 1, gdb_stdout
);
1064 printf_filtered (" in a file compiled without debugging");
1065 section
= SYMBOL_BFD_SECTION (msymbol
);
1066 if (section_is_overlay (section
))
1068 load_addr
= overlay_unmapped_address (load_addr
, section
);
1069 printf_filtered (",\n -- loaded at ");
1070 print_address_numeric (load_addr
, 1, gdb_stdout
);
1071 printf_filtered (" in overlay section %s", section
->name
);
1073 printf_filtered (".\n");
1076 error ("No symbol \"%s\" in current context.", exp
);
1080 printf_filtered ("Symbol \"");
1081 fprintf_symbol_filtered (gdb_stdout
, SYMBOL_NAME (sym
),
1082 current_language
->la_language
, DMGL_ANSI
);
1083 printf_filtered ("\" is ");
1084 val
= SYMBOL_VALUE (sym
);
1085 basereg
= SYMBOL_BASEREG (sym
);
1086 section
= SYMBOL_BFD_SECTION (sym
);
1088 switch (SYMBOL_CLASS (sym
))
1091 case LOC_CONST_BYTES
:
1092 printf_filtered ("constant");
1096 printf_filtered ("a label at address ");
1097 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1099 if (section_is_overlay (section
))
1101 load_addr
= overlay_unmapped_address (load_addr
, section
);
1102 printf_filtered (",\n -- loaded at ");
1103 print_address_numeric (load_addr
, 1, gdb_stdout
);
1104 printf_filtered (" in overlay section %s", section
->name
);
1109 printf_filtered ("a variable in register %s", reg_names
[val
]);
1113 printf_filtered ("static storage at address ");
1114 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (sym
),
1116 if (section_is_overlay (section
))
1118 load_addr
= overlay_unmapped_address (load_addr
, section
);
1119 printf_filtered (",\n -- loaded at ");
1120 print_address_numeric (load_addr
, 1, gdb_stdout
);
1121 printf_filtered (" in overlay section %s", section
->name
);
1126 printf_filtered ("an argument in register %s", reg_names
[val
]);
1129 case LOC_REGPARM_ADDR
:
1130 printf_filtered ("address of an argument in register %s", reg_names
[val
]);
1134 printf_filtered ("an argument at offset %ld", val
);
1138 printf_filtered ("an argument at frame offset %ld", val
);
1142 printf_filtered ("a local variable at frame offset %ld", val
);
1146 printf_filtered ("a reference argument at offset %ld", val
);
1150 printf_filtered ("a variable at offset %ld from register %s",
1151 val
, reg_names
[basereg
]);
1154 case LOC_BASEREG_ARG
:
1155 printf_filtered ("an argument at offset %ld from register %s",
1156 val
, reg_names
[basereg
]);
1160 printf_filtered ("a typedef");
1164 printf_filtered ("a function at address ");
1165 #ifdef GDB_TARGET_MASK_DISAS_PC
1166 print_address_numeric
1167 (load_addr
= GDB_TARGET_MASK_DISAS_PC (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))),
1170 print_address_numeric (load_addr
=BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)),
1173 if (section_is_overlay (section
))
1175 load_addr
= overlay_unmapped_address (load_addr
, section
);
1176 printf_filtered (",\n -- loaded at ");
1177 print_address_numeric (load_addr
, 1, gdb_stdout
);
1178 printf_filtered (" in overlay section %s", section
->name
);
1182 case LOC_UNRESOLVED
:
1184 struct minimal_symbol
*msym
;
1186 msym
= lookup_minimal_symbol (SYMBOL_NAME (sym
), NULL
, NULL
);
1188 printf_filtered ("unresolved");
1191 section
= SYMBOL_BFD_SECTION (msym
);
1192 printf_filtered ("static storage at address ");
1193 print_address_numeric (load_addr
= SYMBOL_VALUE_ADDRESS (msym
),
1195 if (section_is_overlay (section
))
1197 load_addr
= overlay_unmapped_address (load_addr
, section
);
1198 printf_filtered (",\n -- loaded at ");
1199 print_address_numeric (load_addr
, 1, gdb_stdout
);
1200 printf_filtered (" in overlay section %s", section
->name
);
1206 case LOC_OPTIMIZED_OUT
:
1207 printf_filtered ("optimized out");
1211 printf_filtered ("of unknown (botched) type");
1214 printf_filtered (".\n");
1218 x_command (exp
, from_tty
)
1222 struct expression
*expr
;
1223 struct format_data fmt
;
1224 struct cleanup
*old_chain
;
1227 fmt
.format
= last_format
;
1228 fmt
.size
= last_size
;
1231 if (exp
&& *exp
== '/')
1234 fmt
= decode_format (&exp
, last_format
, last_size
);
1237 /* If we have an expression, evaluate it and use it as the address. */
1239 if (exp
!= 0 && *exp
!= 0)
1241 expr
= parse_expression (exp
);
1242 /* Cause expression not to be there any more
1243 if this command is repeated with Newline.
1244 But don't clobber a user-defined command's definition. */
1247 old_chain
= make_cleanup ((make_cleanup_func
) free_current_contents
,
1249 val
= evaluate_expression (expr
);
1250 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_REF
)
1251 val
= value_ind (val
);
1252 /* In rvalue contexts, such as this, functions are coerced into
1253 pointers to functions. This makes "x/i main" work. */
1254 if (/* last_format == 'i'
1255 && */ TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FUNC
1256 && VALUE_LVAL (val
) == lval_memory
)
1257 next_address
= VALUE_ADDRESS (val
);
1259 next_address
= value_as_pointer (val
);
1260 if (VALUE_BFD_SECTION (val
))
1261 next_section
= VALUE_BFD_SECTION (val
);
1262 do_cleanups (old_chain
);
1265 do_examine (fmt
, next_address
, next_section
);
1267 /* If the examine succeeds, we remember its size and format for next time. */
1268 last_size
= fmt
.size
;
1269 last_format
= fmt
.format
;
1271 /* Set a couple of internal variables if appropriate. */
1272 if (last_examine_value
)
1274 /* Make last address examined available to the user as $_. Use
1275 the correct pointer type. */
1276 set_internalvar (lookup_internalvar ("_"),
1277 value_from_longest (
1278 lookup_pointer_type (VALUE_TYPE (last_examine_value
)),
1279 (LONGEST
) last_examine_address
));
1281 /* Make contents of last address examined available to the user as $__.*/
1282 /* If the last value has not been fetched from memory then don't
1283 fetch it now - instead mark it by voiding the $__ variable. */
1284 if (VALUE_LAZY (last_examine_value
))
1285 set_internalvar (lookup_internalvar ("__"),
1286 allocate_value (builtin_type_void
));
1288 set_internalvar (lookup_internalvar ("__"), last_examine_value
);
1293 /* Add an expression to the auto-display chain.
1294 Specify the expression. */
1297 display_command (exp
, from_tty
)
1301 struct format_data fmt
;
1302 register struct expression
*expr
;
1303 register struct display
*new;
1314 fmt
= decode_format (&exp
, 0, 0);
1315 if (fmt
.size
&& fmt
.format
== 0)
1317 if (fmt
.format
== 'i' || fmt
.format
== 's')
1327 innermost_block
= 0;
1328 expr
= parse_expression (exp
);
1330 new = (struct display
*) xmalloc (sizeof (struct display
));
1333 new->block
= innermost_block
;
1334 new->next
= display_chain
;
1335 new->number
= ++display_number
;
1337 new->status
= enabled
;
1338 display_chain
= new;
1340 if (from_tty
&& target_has_execution
)
1341 do_one_display (new);
1354 /* Clear out the display_chain.
1355 Done when new symtabs are loaded, since this invalidates
1356 the types stored in many expressions. */
1361 register struct display
*d
;
1363 while ((d
= display_chain
) != NULL
)
1366 display_chain
= d
->next
;
1371 /* Delete the auto-display number NUM. */
1374 delete_display (num
)
1377 register struct display
*d1
, *d
;
1380 error ("No display number %d.", num
);
1382 if (display_chain
->number
== num
)
1385 display_chain
= d1
->next
;
1389 for (d
= display_chain
; ; d
= d
->next
)
1392 error ("No display number %d.", num
);
1393 if (d
->next
->number
== num
)
1403 /* Delete some values from the auto-display chain.
1404 Specify the element numbers. */
1407 undisplay_command (args
, from_tty
)
1411 register char *p
= args
;
1417 if (query ("Delete all auto-display expressions? "))
1426 while (*p1
>= '0' && *p1
<= '9') p1
++;
1427 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1428 error ("Arguments must be display numbers.");
1432 delete_display (num
);
1435 while (*p
== ' ' || *p
== '\t') p
++;
1440 /* Display a single auto-display.
1441 Do nothing if the display cannot be printed in the current context,
1442 or if the display is disabled. */
1448 int within_current_scope
;
1450 if (d
->status
== disabled
)
1454 within_current_scope
= contained_in (get_selected_block (), d
->block
);
1456 within_current_scope
= 1;
1457 if (!within_current_scope
)
1460 current_display_number
= d
->number
;
1462 annotate_display_begin ();
1463 printf_filtered ("%d", d
->number
);
1464 annotate_display_number_end ();
1465 printf_filtered (": ");
1471 annotate_display_format ();
1473 printf_filtered ("x/");
1474 if (d
->format
.count
!= 1)
1475 printf_filtered ("%d", d
->format
.count
);
1476 printf_filtered ("%c", d
->format
.format
);
1477 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1478 printf_filtered ("%c", d
->format
.size
);
1479 printf_filtered (" ");
1481 annotate_display_expression ();
1483 print_expression (d
->exp
, gdb_stdout
);
1484 annotate_display_expression_end ();
1486 if (d
->format
.count
!= 1)
1487 printf_filtered ("\n");
1489 printf_filtered (" ");
1491 val
= evaluate_expression (d
->exp
);
1492 addr
= value_as_pointer (val
);
1493 if (d
->format
.format
== 'i')
1494 addr
= ADDR_BITS_REMOVE (addr
);
1496 annotate_display_value ();
1498 do_examine (d
->format
, addr
, VALUE_BFD_SECTION (val
));
1502 annotate_display_format ();
1504 if (d
->format
.format
)
1505 printf_filtered ("/%c ", d
->format
.format
);
1507 annotate_display_expression ();
1509 print_expression (d
->exp
, gdb_stdout
);
1510 annotate_display_expression_end ();
1512 printf_filtered (" = ");
1514 annotate_display_expression ();
1516 print_formatted (evaluate_expression (d
->exp
),
1517 d
->format
.format
, d
->format
.size
);
1518 printf_filtered ("\n");
1521 annotate_display_end ();
1523 gdb_flush (gdb_stdout
);
1524 current_display_number
= -1;
1527 /* Display all of the values on the auto-display chain which can be
1528 evaluated in the current scope. */
1533 register struct display
*d
;
1535 for (d
= display_chain
; d
; d
= d
->next
)
1539 /* Delete the auto-display which we were in the process of displaying.
1540 This is done when there is an error or a signal. */
1543 disable_display (num
)
1546 register struct display
*d
;
1548 for (d
= display_chain
; d
; d
= d
->next
)
1549 if (d
->number
== num
)
1551 d
->status
= disabled
;
1554 printf_unfiltered ("No display number %d.\n", num
);
1558 disable_current_display ()
1560 if (current_display_number
>= 0)
1562 disable_display (current_display_number
);
1563 fprintf_unfiltered (gdb_stderr
, "Disabling display %d to avoid infinite recursion.\n",
1564 current_display_number
);
1566 current_display_number
= -1;
1570 display_info (ignore
, from_tty
)
1574 register struct display
*d
;
1577 printf_unfiltered ("There are no auto-display expressions now.\n");
1579 printf_filtered ("Auto-display expressions now in effect:\n\
1580 Num Enb Expression\n");
1582 for (d
= display_chain
; d
; d
= d
->next
)
1584 printf_filtered ("%d: %c ", d
->number
, "ny"[(int)d
->status
]);
1586 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
1588 else if (d
->format
.format
)
1589 printf_filtered ("/%c ", d
->format
.format
);
1590 print_expression (d
->exp
, gdb_stdout
);
1591 if (d
->block
&& !contained_in (get_selected_block (), d
->block
))
1592 printf_filtered (" (cannot be evaluated in the current context)");
1593 printf_filtered ("\n");
1594 gdb_flush (gdb_stdout
);
1599 enable_display (args
, from_tty
)
1603 register char *p
= args
;
1606 register struct display
*d
;
1610 for (d
= display_chain
; d
; d
= d
->next
)
1611 d
->status
= enabled
;
1617 while (*p1
>= '0' && *p1
<= '9')
1619 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1620 error ("Arguments must be display numbers.");
1624 for (d
= display_chain
; d
; d
= d
->next
)
1625 if (d
->number
== num
)
1627 d
->status
= enabled
;
1630 printf_unfiltered ("No display number %d.\n", num
);
1633 while (*p
== ' ' || *p
== '\t')
1640 disable_display_command (args
, from_tty
)
1644 register char *p
= args
;
1646 register struct display
*d
;
1650 for (d
= display_chain
; d
; d
= d
->next
)
1651 d
->status
= disabled
;
1657 while (*p1
>= '0' && *p1
<= '9')
1659 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1660 error ("Arguments must be display numbers.");
1662 disable_display (atoi (p
));
1665 while (*p
== ' ' || *p
== '\t')
1671 /* Print the value in stack frame FRAME of a variable
1672 specified by a struct symbol. */
1675 print_variable_value (var
, frame
, stream
)
1677 struct frame_info
*frame
;
1680 value_ptr val
= read_var_value (var
, frame
);
1682 value_print (val
, stream
, 0, Val_pretty_default
);
1685 /* Print the arguments of a stack frame, given the function FUNC
1686 running in that frame (as a symbol), the info on the frame,
1687 and the number of args according to the stack frame (or -1 if unknown). */
1689 /* References here and elsewhere to "number of args according to the
1690 stack frame" appear in all cases to refer to "number of ints of args
1691 according to the stack frame". At least for VAX, i386, isi. */
1694 print_frame_args (func
, fi
, num
, stream
)
1695 struct symbol
*func
;
1696 struct frame_info
*fi
;
1700 struct block
*b
= NULL
;
1704 register struct symbol
*sym
;
1705 register value_ptr val
;
1706 /* Offset of next stack argument beyond the one we have seen that is
1707 at the highest offset.
1708 -1 if we haven't come to a stack argument yet. */
1709 long highest_offset
= -1;
1711 /* Number of ints of arguments that we have printed so far. */
1712 int args_printed
= 0;
1716 b
= SYMBOL_BLOCK_VALUE (func
);
1717 nsyms
= BLOCK_NSYMS (b
);
1720 for (i
= 0; i
< nsyms
; i
++)
1723 sym
= BLOCK_SYM (b
, i
);
1725 /* Keep track of the highest stack argument offset seen, and
1726 skip over any kinds of symbols we don't care about. */
1728 switch (SYMBOL_CLASS (sym
)) {
1732 long current_offset
= SYMBOL_VALUE (sym
);
1733 arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
1735 /* Compute address of next argument by adding the size of
1736 this argument and rounding to an int boundary. */
1738 = ((current_offset
+ arg_size
+ sizeof (int) - 1)
1739 & ~(sizeof (int) - 1));
1741 /* If this is the highest offset seen yet, set highest_offset. */
1742 if (highest_offset
== -1
1743 || (current_offset
> highest_offset
))
1744 highest_offset
= current_offset
;
1746 /* Add the number of ints we're about to print to args_printed. */
1747 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
1750 /* We care about types of symbols, but don't need to keep track of
1751 stack offsets in them. */
1753 case LOC_REGPARM_ADDR
:
1755 case LOC_BASEREG_ARG
:
1758 /* Other types of symbols we just skip over. */
1763 /* We have to look up the symbol because arguments can have
1764 two entries (one a parameter, one a local) and the one we
1765 want is the local, which lookup_symbol will find for us.
1766 This includes gcc1 (not gcc2) on the sparc when passing a
1767 small structure and gcc2 when the argument type is float
1768 and it is passed as a double and converted to float by
1769 the prologue (in the latter case the type of the LOC_ARG
1770 symbol is double and the type of the LOC_LOCAL symbol is
1772 /* But if the parameter name is null, don't try it.
1773 Null parameter names occur on the RS/6000, for traceback tables.
1774 FIXME, should we even print them? */
1776 if (*SYMBOL_NAME (sym
))
1778 struct symbol
*nsym
;
1779 nsym
= lookup_symbol
1781 b
, VAR_NAMESPACE
, (int *)NULL
, (struct symtab
**)NULL
);
1782 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
)
1784 /* There is a LOC_ARG/LOC_REGISTER pair. This means that
1785 it was passed on the stack and loaded into a register,
1786 or passed in a register and stored in a stack slot.
1787 GDB 3.x used the LOC_ARG; GDB 4.0-4.11 used the LOC_REGISTER.
1789 Reasons for using the LOC_ARG:
1790 (1) because find_saved_registers may be slow for remote
1792 (2) because registers are often re-used and stack slots
1793 rarely (never?) are. Therefore using the stack slot is
1794 much less likely to print garbage.
1796 Reasons why we might want to use the LOC_REGISTER:
1797 (1) So that the backtrace prints the same value as
1798 "print foo". I see no compelling reason why this needs
1799 to be the case; having the backtrace print the value which
1800 was passed in, and "print foo" print the value as modified
1801 within the called function, makes perfect sense to me.
1803 Additional note: It might be nice if "info args" displayed
1805 One more note: There is a case with sparc structure passing
1806 where we need to use the LOC_REGISTER, but this is dealt with
1807 by creating a single LOC_REGPARM in symbol reading. */
1809 /* Leave sym (the LOC_ARG) alone. */
1816 /* Print the current arg. */
1818 fprintf_filtered (stream
, ", ");
1821 annotate_arg_begin ();
1823 fprintf_symbol_filtered (stream
, SYMBOL_SOURCE_NAME (sym
),
1824 SYMBOL_LANGUAGE (sym
), DMGL_PARAMS
| DMGL_ANSI
);
1825 annotate_arg_name_end ();
1826 fputs_filtered ("=", stream
);
1828 /* Avoid value_print because it will deref ref parameters. We just
1829 want to print their addresses. Print ??? for args whose address
1830 we do not know. We pass 2 as "recurse" to val_print because our
1831 standard indentation here is 4 spaces, and val_print indents
1832 2 for each recurse. */
1833 val
= read_var_value (sym
, fi
);
1835 annotate_arg_value (val
== NULL
? NULL
: VALUE_TYPE (val
));
1839 #ifdef GDB_TARGET_IS_D10V
1840 if (SYMBOL_CLASS(sym
) == LOC_REGPARM
&& TYPE_CODE(VALUE_TYPE(val
)) == TYPE_CODE_PTR
)
1841 TYPE_LENGTH(VALUE_TYPE(val
)) = 2;
1843 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
), VALUE_ADDRESS (val
),
1844 stream
, 0, 0, 2, Val_no_prettyprint
);
1847 fputs_filtered ("???", stream
);
1849 annotate_arg_end ();
1854 /* Don't print nameless args in situations where we don't know
1855 enough about the stack to find them. */
1860 if (highest_offset
== -1)
1861 start
= FRAME_ARGS_SKIP
;
1863 start
= highest_offset
;
1865 print_frame_nameless_args (fi
, start
, num
- args_printed
,
1870 /* Print nameless args on STREAM.
1871 FI is the frameinfo for this frame, START is the offset
1872 of the first nameless arg, and NUM is the number of nameless args to
1873 print. FIRST is nonzero if this is the first argument (not just
1874 the first nameless arg). */
1877 print_frame_nameless_args (fi
, start
, num
, first
, stream
)
1878 struct frame_info
*fi
;
1888 for (i
= 0; i
< num
; i
++)
1891 #ifdef NAMELESS_ARG_VALUE
1892 NAMELESS_ARG_VALUE (fi
, start
, &arg_value
);
1894 argsaddr
= FRAME_ARGS_ADDRESS (fi
);
1898 arg_value
= read_memory_integer (argsaddr
+ start
, sizeof (int));
1902 fprintf_filtered (stream
, ", ");
1904 #ifdef PRINT_NAMELESS_INTEGER
1905 PRINT_NAMELESS_INTEGER (stream
, arg_value
);
1907 #ifdef PRINT_TYPELESS_INTEGER
1908 PRINT_TYPELESS_INTEGER (stream
, builtin_type_int
, (LONGEST
) arg_value
);
1910 fprintf_filtered (stream
, "%ld", arg_value
);
1911 #endif /* PRINT_TYPELESS_INTEGER */
1912 #endif /* PRINT_NAMELESS_INTEGER */
1914 start
+= sizeof (int);
1920 printf_command (arg
, from_tty
)
1925 register char *s
= arg
;
1927 value_ptr
*val_args
;
1929 char *current_substring
;
1931 int allocated_args
= 20;
1932 struct cleanup
*old_cleanups
;
1934 val_args
= (value_ptr
*) xmalloc (allocated_args
* sizeof (value_ptr
));
1935 old_cleanups
= make_cleanup ((make_cleanup_func
) free_current_contents
,
1939 error_no_arg ("format-control string and values to print");
1941 /* Skip white space before format string */
1942 while (*s
== ' ' || *s
== '\t') s
++;
1944 /* A format string should follow, enveloped in double quotes */
1946 error ("Bad format string, missing '\"'.");
1948 /* Parse the format-control string and copy it into the string STRING,
1949 processing some kinds of escape sequence. */
1951 f
= string
= (char *) alloca (strlen (s
) + 1);
1959 error ("Bad format string, non-terminated '\"'.");
1971 *f
++ = '\007'; /* Bell */
1996 /* ??? TODO: handle other escape sequences */
1997 error ("Unrecognized escape character \\%c in format string.",
2007 /* Skip over " and following space and comma. */
2010 while (*s
== ' ' || *s
== '\t') s
++;
2012 if (*s
!= ',' && *s
!= 0)
2013 error ("Invalid argument syntax");
2016 while (*s
== ' ' || *s
== '\t') s
++;
2018 /* Need extra space for the '\0's. Doubling the size is sufficient. */
2019 substrings
= alloca (strlen (string
) * 2);
2020 current_substring
= substrings
;
2023 /* Now scan the string for %-specs and see what kinds of args they want.
2024 argclass[I] classifies the %-specs so we can give printf_filtered
2025 something of the right size. */
2027 enum argclass
{no_arg
, int_arg
, string_arg
, double_arg
, long_long_arg
};
2028 enum argclass
*argclass
;
2029 enum argclass this_argclass
;
2035 argclass
= (enum argclass
*) alloca (strlen (s
) * sizeof *argclass
);
2043 while (strchr ("0123456789.hlL-+ #", *f
))
2045 if (*f
== 'l' || *f
== 'L')
2052 this_argclass
= string_arg
;
2058 this_argclass
= double_arg
;
2062 error ("`*' not supported for precision or width in printf");
2065 error ("Format specifier `n' not supported in printf");
2068 this_argclass
= no_arg
;
2073 this_argclass
= long_long_arg
;
2075 this_argclass
= int_arg
;
2079 if (this_argclass
!= no_arg
)
2081 strncpy (current_substring
, last_arg
, f
- last_arg
);
2082 current_substring
+= f
- last_arg
;
2083 *current_substring
++ = '\0';
2085 argclass
[nargs_wanted
++] = this_argclass
;
2089 /* Now, parse all arguments and evaluate them.
2090 Store the VALUEs in VAL_ARGS. */
2095 if (nargs
== allocated_args
)
2096 val_args
= (value_ptr
*) xrealloc ((char *) val_args
,
2097 (allocated_args
*= 2)
2098 * sizeof (value_ptr
));
2100 val_args
[nargs
] = parse_to_comma_and_eval (&s1
);
2102 /* If format string wants a float, unchecked-convert the value to
2103 floating point of the same size */
2105 if (argclass
[nargs
] == double_arg
)
2107 struct type
*type
= VALUE_TYPE (val_args
[nargs
]);
2108 if (TYPE_LENGTH (type
) == sizeof (float))
2109 VALUE_TYPE (val_args
[nargs
]) = builtin_type_float
;
2110 if (TYPE_LENGTH (type
) == sizeof (double))
2111 VALUE_TYPE (val_args
[nargs
]) = builtin_type_double
;
2119 if (nargs
!= nargs_wanted
)
2120 error ("Wrong number of arguments for specified format-string");
2122 /* Now actually print them. */
2123 current_substring
= substrings
;
2124 for (i
= 0; i
< nargs
; i
++)
2126 switch (argclass
[i
])
2133 tem
= value_as_pointer (val_args
[i
]);
2135 /* This is a %s argument. Find the length of the string. */
2140 read_memory_section (tem
+ j
, &c
, 1,
2141 VALUE_BFD_SECTION (val_args
[i
]));
2146 /* Copy the string contents into a string inside GDB. */
2147 str
= (char *) alloca (j
+ 1);
2148 read_memory_section (tem
, str
, j
, VALUE_BFD_SECTION (val_args
[i
]));
2151 printf_filtered (current_substring
, str
);
2156 double val
= value_as_double (val_args
[i
]);
2157 printf_filtered (current_substring
, val
);
2161 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2163 long long val
= value_as_long (val_args
[i
]);
2164 printf_filtered (current_substring
, val
);
2168 error ("long long not supported in printf");
2172 /* FIXME: there should be separate int_arg and long_arg. */
2173 long val
= value_as_long (val_args
[i
]);
2174 printf_filtered (current_substring
, val
);
2178 error ("internal error in printf_command");
2180 /* Skip to the next substring. */
2181 current_substring
+= strlen (current_substring
) + 1;
2183 /* Print the portion of the format string after the last argument. */
2184 printf_filtered (last_arg
);
2186 do_cleanups (old_cleanups
);
2189 /* Dump a specified section of assembly code. With no command line
2190 arguments, this command will dump the assembly code for the
2191 function surrounding the pc value in the selected frame. With one
2192 argument, it will dump the assembly code surrounding that pc value.
2193 Two arguments are interpeted as bounds within which to dump
2198 disassemble_command (arg
, from_tty
)
2202 CORE_ADDR low
, high
;
2204 CORE_ADDR pc
, pc_masked
;
2210 if (!selected_frame
)
2211 error ("No frame selected.\n");
2213 pc
= get_frame_pc (selected_frame
);
2214 if (find_pc_partial_function (pc
, &name
, &low
, &high
) == 0)
2215 error ("No function contains program counter for selected frame.\n");
2216 low
+= FUNCTION_START_OFFSET
;
2218 else if (!(space_index
= (char *) strchr (arg
, ' ')))
2221 pc
= parse_and_eval_address (arg
);
2222 if (find_pc_partial_function (pc
, &name
, &low
, &high
) == 0)
2223 error ("No function contains specified address.\n");
2224 low
+= FUNCTION_START_OFFSET
;
2228 /* Two arguments. */
2229 *space_index
= '\0';
2230 low
= parse_and_eval_address (arg
);
2231 high
= parse_and_eval_address (space_index
+ 1);
2234 printf_filtered ("Dump of assembler code ");
2237 printf_filtered ("for function %s:\n", name
);
2241 printf_filtered ("from ");
2242 print_address_numeric (low
, 1, gdb_stdout
);
2243 printf_filtered (" to ");
2244 print_address_numeric (high
, 1, gdb_stdout
);
2245 printf_filtered (":\n");
2248 /* Dump the specified range. */
2251 #ifdef GDB_TARGET_MASK_DISAS_PC
2252 pc_masked
= GDB_TARGET_MASK_DISAS_PC (pc
);
2257 while (pc_masked
< high
)
2260 print_address (pc_masked
, gdb_stdout
);
2261 printf_filtered (":\t");
2262 /* We often wrap here if there are long symbolic names. */
2264 pc
+= print_insn (pc
, gdb_stdout
);
2265 printf_filtered ("\n");
2267 #ifdef GDB_TARGET_MASK_DISAS_PC
2268 pc_masked
= GDB_TARGET_MASK_DISAS_PC (pc
);
2273 printf_filtered ("End of assembler dump.\n");
2274 gdb_flush (gdb_stdout
);
2277 /* Print the instruction at address MEMADDR in debugged memory,
2278 on STREAM. Returns length of the instruction, in bytes. */
2281 print_insn (memaddr
, stream
)
2285 /* If there's no disassembler, something is very wrong. */
2286 if (tm_print_insn
== NULL
)
2289 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
2290 tm_print_insn_info
.endian
= BFD_ENDIAN_BIG
;
2292 tm_print_insn_info
.endian
= BFD_ENDIAN_LITTLE
;
2294 if (target_architecture
!= NULL
)
2295 tm_print_insn_info
.mach
= target_architecture
->mach
;
2296 /* else: should set .mach=0 but some disassemblers don't grok this */
2298 return (*tm_print_insn
) (memaddr
, &tm_print_insn_info
);
2303 _initialize_printcmd ()
2305 current_display_number
= -1;
2307 add_info ("address", address_info
,
2308 "Describe where symbol SYM is stored.");
2310 add_info ("symbol", sym_info
,
2311 "Describe what symbol is at location ADDR.\n\
2312 Only for symbols with fixed locations (global or static scope).");
2314 add_com ("x", class_vars
, x_command
,
2315 concat ("Examine memory: x/FMT ADDRESS.\n\
2316 ADDRESS is an expression for the memory address to examine.\n\
2317 FMT is a repeat count followed by a format letter and a size letter.\n\
2318 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2319 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n",
2320 "Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2321 The specified number of objects of the specified size are printed\n\
2322 according to the format.\n\n\
2323 Defaults for format and size letters are those previously used.\n\
2324 Default count is 1. Default address is following last thing printed\n\
2325 with this command or \"print\".", NULL
));
2327 add_com ("disassemble", class_vars
, disassemble_command
,
2328 "Disassemble a specified section of memory.\n\
2329 Default is the function surrounding the pc of the selected frame.\n\
2330 With a single argument, the function surrounding that address is dumped.\n\
2331 Two arguments are taken as a range of memory to dump.");
2334 add_com ("whereis", class_vars
, whereis_command
,
2335 "Print line number and file of definition of variable.");
2338 add_info ("display", display_info
,
2339 "Expressions to display when program stops, with code numbers.");
2341 add_cmd ("undisplay", class_vars
, undisplay_command
,
2342 "Cancel some expressions to be displayed when program stops.\n\
2343 Arguments are the code numbers of the expressions to stop displaying.\n\
2344 No argument means cancel all automatic-display expressions.\n\
2345 \"delete display\" has the same effect as this command.\n\
2346 Do \"info display\" to see current list of code numbers.",
2349 add_com ("display", class_vars
, display_command
,
2350 "Print value of expression EXP each time the program stops.\n\
2351 /FMT may be used before EXP as in the \"print\" command.\n\
2352 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2353 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2354 and examining is done as in the \"x\" command.\n\n\
2355 With no argument, display all currently requested auto-display expressions.\n\
2356 Use \"undisplay\" to cancel display requests previously made."
2359 add_cmd ("display", class_vars
, enable_display
,
2360 "Enable some expressions to be displayed when program stops.\n\
2361 Arguments are the code numbers of the expressions to resume displaying.\n\
2362 No argument means enable all automatic-display expressions.\n\
2363 Do \"info display\" to see current list of code numbers.", &enablelist
);
2365 add_cmd ("display", class_vars
, disable_display_command
,
2366 "Disable some expressions to be displayed when program stops.\n\
2367 Arguments are the code numbers of the expressions to stop displaying.\n\
2368 No argument means disable all automatic-display expressions.\n\
2369 Do \"info display\" to see current list of code numbers.", &disablelist
);
2371 add_cmd ("display", class_vars
, undisplay_command
,
2372 "Cancel some expressions to be displayed when program stops.\n\
2373 Arguments are the code numbers of the expressions to stop displaying.\n\
2374 No argument means cancel all automatic-display expressions.\n\
2375 Do \"info display\" to see current list of code numbers.", &deletelist
);
2377 add_com ("printf", class_vars
, printf_command
,
2378 "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2379 This is useful for formatted output in user-defined commands.");
2381 add_com ("output", class_vars
, output_command
,
2382 "Like \"print\" but don't put in value history and don't print newline.\n\
2383 This is useful in user-defined commands.");
2385 add_prefix_cmd ("set", class_vars
, set_command
,
2386 concat ("Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2387 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2388 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2389 with $), a register (a few standard names starting with $), or an actual\n\
2390 variable in the program being debugged. EXP is any valid expression.\n",
2391 "Use \"set variable\" for variables with names identical to set subcommands.\n\
2392 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2393 You can see these environment settings with the \"show\" command.", NULL
),
2394 &setlist
, "set ", 1, &cmdlist
);
2396 /* "call" is the same as "set", but handy for dbx users to call fns. */
2397 add_com ("call", class_vars
, call_command
,
2398 "Call a function in the program.\n\
2399 The argument is the function name and arguments, in the notation of the\n\
2400 current working language. The result is printed and saved in the value\n\
2401 history, if it is not void.");
2403 add_cmd ("variable", class_vars
, set_command
,
2404 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2405 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2406 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2407 with $), a register (a few standard names starting with $), or an actual\n\
2408 variable in the program being debugged. EXP is any valid expression.\n\
2409 This may usually be abbreviated to simply \"set\".",
2412 add_com ("print", class_vars
, print_command
,
2413 concat ("Print value of expression EXP.\n\
2414 Variables accessible are those of the lexical environment of the selected\n\
2415 stack frame, plus all those whose scope is global or an entire file.\n\
2417 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2418 $$NUM refers to NUM'th value back from the last one.\n\
2419 Names starting with $ refer to registers (with the values they would have\n",
2420 "if the program were to return to the stack frame now selected, restoring\n\
2421 all registers saved by frames farther in) or else to debugger\n\
2422 \"convenience\" variables (any such name not a known register).\n\
2423 Use assignment expressions to give values to convenience variables.\n",
2425 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2426 @ is a binary operator for treating consecutive data objects\n\
2427 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2428 element is FOO, whose second element is stored in the space following\n\
2429 where FOO is stored, etc. FOO must be an expression whose value\n\
2430 resides in memory.\n",
2432 EXP may be preceded with /FMT, where FMT is a format letter\n\
2433 but no count or size letter (see \"x\" command).", NULL
));
2434 add_com_alias ("p", "print", class_vars
, 1);
2436 add_com ("inspect", class_vars
, inspect_command
,
2437 "Same as \"print\" command, except that if you are running in the epoch\n\
2438 environment, the value is printed in its own window.");
2441 add_set_cmd ("max-symbolic-offset", no_class
, var_uinteger
,
2442 (char *)&max_symbolic_offset
,
2443 "Set the largest offset that will be printed in <symbol+1234> form.",
2447 add_set_cmd ("symbol-filename", no_class
, var_boolean
,
2448 (char *)&print_symbol_filename
,
2449 "Set printing of source filename and line number with <symbol>.",
2453 /* For examine/instruction a single byte quantity is specified as
2454 the data. This avoids problems with value_at_lazy() requiring a
2455 valid data type (and rejecting VOID). */
2456 examine_i_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_i_type", NULL
);
2458 examine_b_type
= init_type (TYPE_CODE_INT
, 1, 0, "examine_b_type", NULL
);
2459 examine_h_type
= init_type (TYPE_CODE_INT
, 2, 0, "examine_h_type", NULL
);
2460 examine_w_type
= init_type (TYPE_CODE_INT
, 4, 0, "examine_w_type", NULL
);
2461 examine_g_type
= init_type (TYPE_CODE_INT
, 8, 0, "examine_g_type", NULL
);
2463 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info
, gdb_stdout
, (fprintf_ftype
)fprintf_filtered
);
2464 tm_print_insn_info
.flavour
= bfd_target_unknown_flavour
;
2465 tm_print_insn_info
.read_memory_func
= dis_asm_read_memory
;
2466 tm_print_insn_info
.memory_error_func
= dis_asm_memory_error
;
2467 tm_print_insn_info
.print_address_func
= dis_asm_print_address
;