1 /* Print values for GNU debugger GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1993, 1994
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
29 #include "expression.h"
33 #include "breakpoint.h"
38 extern int asm_demangle
; /* Whether to demangle syms in asm printouts */
39 extern int addressprint
; /* Whether to print hex addresses in HLL " */
48 /* Last specified output format. */
50 static char last_format
= 'x';
52 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
54 static char last_size
= 'w';
56 /* Default address to examine next. */
58 static CORE_ADDR next_address
;
60 /* Last address examined. */
62 static CORE_ADDR last_examine_address
;
64 /* Contents of last address examined.
65 This is not valid past the end of the `x' command! */
67 static value_ptr last_examine_value
;
69 /* Largest offset between a symbolic value and an address, that will be
70 printed as `0x1234 <symbol+offset>'. */
72 static unsigned int max_symbolic_offset
= UINT_MAX
;
74 /* Append the source filename and linenumber of the symbol when
75 printing a symbolic value as `<symbol at filename:linenum>' if set. */
76 static int print_symbol_filename
= 0;
78 /* Number of auto-display expression currently being displayed.
79 So that we can disable it if we get an error or a signal within it.
80 -1 when not doing one. */
82 int current_display_number
;
84 /* Flag to low-level print routines that this value is being printed
85 in an epoch window. We'd like to pass this as a parameter, but
86 every routine would need to take it. Perhaps we can encapsulate
87 this in the I/O stream once we have GNU stdio. */
95 /* FIXME: Should we be printing * for references as well as pointers? */
97 && TYPE_CODE (t
) == TYPE_CODE_PTR
98 && TYPE_CODE (TYPE_TARGET_TYPE (t
)) != TYPE_CODE_VOID
)
99 printf_filtered ("*");
101 printf_filtered ("-");
106 /* Chain link to next auto-display item. */
107 struct display
*next
;
108 /* Expression to be evaluated and displayed. */
109 struct expression
*exp
;
110 /* Item number of this auto-display item. */
112 /* Display format specified. */
113 struct format_data format
;
114 /* Innermost block required by this expression when evaluated */
116 /* Status of this display (enabled or disabled) */
120 /* Chain of expressions whose values should be displayed
121 automatically each time the program stops. */
123 static struct display
*display_chain
;
125 static int display_number
;
127 /* Prototypes for local functions */
130 delete_display
PARAMS ((int));
133 enable_display
PARAMS ((char *, int));
136 disable_display_command
PARAMS ((char *, int));
139 disassemble_command
PARAMS ((char *, int));
142 printf_command
PARAMS ((char *, int));
145 print_frame_nameless_args
PARAMS ((struct frame_info
*, long, int, int,
149 display_info
PARAMS ((char *, int));
152 do_one_display
PARAMS ((struct display
*));
155 undisplay_command
PARAMS ((char *, int));
158 free_display
PARAMS ((struct display
*));
161 display_command
PARAMS ((char *, int));
164 x_command
PARAMS ((char *, int));
167 address_info
PARAMS ((char *, int));
170 set_command
PARAMS ((char *, int));
173 output_command
PARAMS ((char *, int));
176 call_command
PARAMS ((char *, int));
179 inspect_command
PARAMS ((char *, int));
182 print_command
PARAMS ((char *, int));
185 print_command_1
PARAMS ((char *, int, int));
188 validate_format
PARAMS ((struct format_data
, char *));
191 do_examine
PARAMS ((struct format_data
, CORE_ADDR
));
194 print_formatted
PARAMS ((value_ptr
, int, int));
196 static struct format_data
197 decode_format
PARAMS ((char **, int, int));
200 /* Decode a format specification. *STRING_PTR should point to it.
201 OFORMAT and OSIZE are used as defaults for the format and size
202 if none are given in the format specification.
203 If OSIZE is zero, then the size field of the returned value
204 should be set only if a size is explicitly specified by the
206 The structure returned describes all the data
207 found in the specification. In addition, *STRING_PTR is advanced
208 past the specification and past all whitespace following it. */
210 static struct format_data
211 decode_format (string_ptr
, oformat
, osize
)
216 struct format_data val
;
217 register char *p
= *string_ptr
;
223 if (*p
>= '0' && *p
<= '9')
224 val
.count
= atoi (p
);
225 while (*p
>= '0' && *p
<= '9') p
++;
227 /* Now process size or format letters that follow. */
231 if (*p
== 'b' || *p
== 'h' || *p
== 'w' || *p
== 'g')
233 else if (*p
>= 'a' && *p
<= 'z')
239 while (*p
== ' ' || *p
== '\t') p
++;
242 /* Set defaults for format and size if not specified. */
243 if (val
.format
== '?')
247 /* Neither has been specified. */
248 val
.format
= oformat
;
252 /* If a size is specified, any format makes a reasonable
253 default except 'i'. */
254 val
.format
= oformat
== 'i' ? 'x' : oformat
;
256 else if (val
.size
== '?')
261 /* Pick the appropriate size for an address. */
262 #if TARGET_PTR_BIT == 64
263 val
.size
= osize
? 'g' : osize
;
266 #if TARGET_PTR_BIT == 32
267 val
.size
= osize
? 'w' : osize
;
270 #if TARGET_PTR_BIT == 16
271 val
.size
= osize
? 'h' : osize
;
274 #error Bad value for TARGET_PTR_BIT
280 /* Floating point has to be word or giantword. */
281 if (osize
== 'w' || osize
== 'g')
284 /* Default it to giantword if the last used size is not
286 val
.size
= osize
? 'g' : osize
;
289 /* Characters default to one byte. */
290 val
.size
= osize
? 'b' : osize
;
293 /* The default is the size most recently specified. */
300 /* Print value VAL on gdb_stdout according to FORMAT, a letter or 0.
301 Do not end with a newline.
302 0 means print VAL according to its own type.
303 SIZE is the letter for the size of datum being printed.
304 This is used to pad hex numbers so they line up. */
307 print_formatted (val
, format
, size
)
308 register value_ptr val
;
312 int len
= TYPE_LENGTH (VALUE_TYPE (val
));
314 if (VALUE_LVAL (val
) == lval_memory
)
315 next_address
= VALUE_ADDRESS (val
) + len
;
320 next_address
= VALUE_ADDRESS (val
)
321 + value_print (value_addr (val
), gdb_stdout
, format
, Val_pretty_default
);
325 /* The old comment says
326 "Force output out, print_insn not using _filtered".
327 I'm not completely sure what that means, I suspect most print_insn
328 now do use _filtered, so I guess it's obsolete. */
329 /* We often wrap here if there are long symbolic names. */
331 next_address
= VALUE_ADDRESS (val
)
332 + print_insn (VALUE_ADDRESS (val
), gdb_stdout
);
337 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_ARRAY
338 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_STRING
339 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_STRUCT
340 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_UNION
341 || VALUE_REPEATED (val
))
342 value_print (val
, gdb_stdout
, format
, Val_pretty_default
);
344 print_scalar_formatted (VALUE_CONTENTS (val
), VALUE_TYPE (val
),
345 format
, size
, gdb_stdout
);
349 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
350 according to letters FORMAT and SIZE on STREAM.
351 FORMAT may not be zero. Formats s and i are not supported at this level.
353 This is how the elements of an array or structure are printed
357 print_scalar_formatted (valaddr
, type
, format
, size
, stream
)
365 int len
= TYPE_LENGTH (type
);
367 if (len
> sizeof (LONGEST
)
375 /* We can't print it normally, but we can print it in hex.
376 Printing it in the wrong radix is more useful than saying
377 "use /x, you dummy". */
378 /* FIXME: we could also do octal or binary if that was the
380 /* FIXME: we should be using the size field to give us a minimum
381 field width to print. */
382 val_print_type_code_int (type
, valaddr
, stream
);
387 val_long
= unpack_long (type
, valaddr
);
389 /* If we are printing it as unsigned, truncate it in case it is actually
390 a negative signed value (e.g. "print/u (short)-1" should print 65535
391 (if shorts are 16 bits) instead of 4294967295). */
394 if (len
< sizeof (LONGEST
))
395 val_long
&= ((LONGEST
) 1 << HOST_CHAR_BIT
* len
) - 1;
403 /* no size specified, like in print. Print varying # of digits. */
404 print_longest (stream
, 'x', 1, val_long
);
413 print_longest (stream
, size
, 1, val_long
);
416 error ("Undefined output size \"%c\".", size
);
421 print_longest (stream
, 'd', 1, val_long
);
425 print_longest (stream
, 'u', 0, val_long
);
430 print_longest (stream
, 'o', 1, val_long
);
432 fprintf_filtered (stream
, "0");
436 print_address (unpack_pointer (type
, valaddr
), stream
);
440 value_print (value_from_longest (builtin_type_char
, val_long
), stream
, 0,
445 if (len
== sizeof (float))
446 type
= builtin_type_float
;
447 else if (len
== sizeof (double))
448 type
= builtin_type_double
;
449 print_floating (valaddr
, type
, stream
);
456 /* Binary; 't' stands for "two". */
458 char bits
[8*(sizeof val_long
) + 1];
463 width
= 8*(sizeof val_long
);
480 error ("Undefined output size \"%c\".", size
);
486 bits
[width
] = (val_long
& 1) ? '1' : '0';
491 while (*cp
&& *cp
== '0')
496 fprintf_filtered (stream
, local_binary_format_prefix());
497 fprintf_filtered (stream
, cp
);
498 fprintf_filtered (stream
, local_binary_format_suffix());
503 error ("Undefined output format \"%c\".", format
);
507 /* Specify default address for `x' command.
508 `info lines' uses this. */
511 set_next_address (addr
)
516 /* Make address available to the user as $_. */
517 set_internalvar (lookup_internalvar ("_"),
518 value_from_longest (lookup_pointer_type (builtin_type_void
),
522 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
523 after LEADIN. Print nothing if no symbolic name is found nearby.
524 Optionally also print source file and line number, if available.
525 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
526 or to interpret it as a possible C++ name and convert it back to source
527 form. However note that DO_DEMANGLE can be overridden by the specific
528 settings of the demangle and asm_demangle variables. */
531 print_address_symbolic (addr
, stream
, do_demangle
, leadin
)
537 struct minimal_symbol
*msymbol
;
538 struct symbol
*symbol
;
539 struct symtab
*symtab
= 0;
540 CORE_ADDR name_location
= 0;
543 /* First try to find the address in the symbol table, then
544 in the minsyms. Take the closest one. */
546 /* This is defective in the sense that it only finds text symbols. So
547 really this is kind of pointless--we should make sure that the
548 minimal symbols have everything we need (by changing that we could
549 save some memory, but for many debug format--ELF/DWARF or
550 anything/stabs--it would be inconvenient to eliminate those minimal
552 symbol
= find_pc_function (addr
);
554 name_location
= BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
));
559 name
= SYMBOL_SOURCE_NAME (symbol
);
561 name
= SYMBOL_LINKAGE_NAME (symbol
);
564 msymbol
= lookup_minimal_symbol_by_pc (addr
);
567 if (SYMBOL_VALUE_ADDRESS (msymbol
) > name_location
|| symbol
== NULL
)
569 /* The msymbol is closer to the address than the symbol;
570 use the msymbol instead. */
573 name_location
= SYMBOL_VALUE_ADDRESS (msymbol
);
575 name
= SYMBOL_SOURCE_NAME (msymbol
);
577 name
= SYMBOL_LINKAGE_NAME (msymbol
);
580 if (symbol
== NULL
&& msymbol
== NULL
)
583 /* If the nearest symbol is too far away, don't print anything symbolic. */
585 /* For when CORE_ADDR is larger than unsigned int, we do math in
586 CORE_ADDR. But when we detect unsigned wraparound in the
587 CORE_ADDR math, we ignore this test and print the offset,
588 because addr+max_symbolic_offset has wrapped through the end
589 of the address space back to the beginning, giving bogus comparison. */
590 if (addr
> name_location
+ max_symbolic_offset
591 && name_location
+ max_symbolic_offset
> name_location
)
594 fputs_filtered (leadin
, stream
);
595 fputs_filtered ("<", stream
);
596 fputs_filtered (name
, stream
);
597 if (addr
!= name_location
)
598 fprintf_filtered (stream
, "+%u", (unsigned int)(addr
- name_location
));
600 /* Append source filename and line number if desired. Give specific
601 line # of this addr, if we have it; else line # of the nearest symbol. */
602 if (print_symbol_filename
)
604 struct symtab_and_line sal
;
606 sal
= find_pc_line (addr
, 0);
608 fprintf_filtered (stream
, " at %s:%d", sal
.symtab
->filename
, sal
.line
);
609 else if (symtab
&& symbol
&& symbol
->line
)
610 fprintf_filtered (stream
, " at %s:%d", symtab
->filename
, symbol
->line
);
612 fprintf_filtered (stream
, " in %s", symtab
->filename
);
614 fputs_filtered (">", stream
);
617 /* Print address ADDR on STREAM. USE_LOCAL means the same thing as for
620 print_address_numeric (addr
, use_local
, stream
)
625 /* This assumes a CORE_ADDR can fit in a LONGEST. Probably a safe
626 assumption. We pass use_local but I'm not completely sure whether
627 that is correct. When (if ever) should we *not* use_local? */
628 print_longest (stream
, 'x', 1, (unsigned LONGEST
) addr
);
631 /* Print address ADDR symbolically on STREAM.
632 First print it as a number. Then perhaps print
633 <SYMBOL + OFFSET> after the number. */
636 print_address (addr
, stream
)
640 print_address_numeric (addr
, 1, stream
);
641 print_address_symbolic (addr
, stream
, asm_demangle
, " ");
644 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
645 controls whether to print the symbolic name "raw" or demangled.
646 Global setting "addressprint" controls whether to print hex address
650 print_address_demangle (addr
, stream
, do_demangle
)
657 fprintf_filtered (stream
, "0");
659 else if (addressprint
)
661 print_address_numeric (addr
, 1, stream
);
662 print_address_symbolic (addr
, stream
, do_demangle
, " ");
666 print_address_symbolic (addr
, stream
, do_demangle
, "");
671 /* These are the types that $__ will get after an examine command of one
674 static struct type
*examine_b_type
;
675 static struct type
*examine_h_type
;
676 static struct type
*examine_w_type
;
677 static struct type
*examine_g_type
;
679 /* Examine data at address ADDR in format FMT.
680 Fetch it from memory and print on gdb_stdout. */
683 do_examine (fmt
, addr
)
684 struct format_data fmt
;
687 register char format
= 0;
689 register int count
= 1;
690 struct type
*val_type
= NULL
;
692 register int maxelts
;
699 /* String or instruction format implies fetch single bytes
700 regardless of the specified size. */
701 if (format
== 's' || format
== 'i')
705 val_type
= examine_b_type
;
706 else if (size
== 'h')
707 val_type
= examine_h_type
;
708 else if (size
== 'w')
709 val_type
= examine_w_type
;
710 else if (size
== 'g')
711 val_type
= examine_g_type
;
718 if (format
== 's' || format
== 'i')
721 /* Print as many objects as specified in COUNT, at most maxelts per line,
722 with the address of the next one at the start of each line. */
726 print_address (next_address
, gdb_stdout
);
727 printf_filtered (":");
732 printf_filtered ("\t");
733 /* Note that print_formatted sets next_address for the next
735 last_examine_address
= next_address
;
736 last_examine_value
= value_at (val_type
, next_address
);
737 print_formatted (last_examine_value
, format
, size
);
739 printf_filtered ("\n");
740 gdb_flush (gdb_stdout
);
745 validate_format (fmt
, cmdname
)
746 struct format_data fmt
;
750 error ("Size letters are meaningless in \"%s\" command.", cmdname
);
752 error ("Item count other than 1 is meaningless in \"%s\" command.",
754 if (fmt
.format
== 'i' || fmt
.format
== 's')
755 error ("Format letter \"%c\" is meaningless in \"%s\" command.",
756 fmt
.format
, cmdname
);
759 /* Evaluate string EXP as an expression in the current language and
760 print the resulting value. EXP may contain a format specifier as the
761 first argument ("/x myvar" for example, to print myvar in hex).
765 print_command_1 (exp
, inspect
, voidprint
)
770 struct expression
*expr
;
771 register struct cleanup
*old_chain
= 0;
772 register char format
= 0;
773 register value_ptr val
;
774 struct format_data fmt
;
777 /* Pass inspect flag to the rest of the print routines in a global (sigh). */
778 inspect_it
= inspect
;
780 if (exp
&& *exp
== '/')
783 fmt
= decode_format (&exp
, last_format
, 0);
784 validate_format (fmt
, "print");
785 last_format
= format
= fmt
.format
;
796 extern int objectprint
;
798 expr
= parse_expression (exp
);
799 old_chain
= make_cleanup (free_current_contents
, &expr
);
801 val
= evaluate_expression (expr
);
803 /* C++: figure out what type we actually want to print it as. */
804 type
= VALUE_TYPE (val
);
807 && ( TYPE_CODE (type
) == TYPE_CODE_PTR
808 || TYPE_CODE (type
) == TYPE_CODE_REF
)
809 && ( TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
810 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_UNION
))
814 v
= value_from_vtable_info (val
, TYPE_TARGET_TYPE (type
));
818 type
= VALUE_TYPE (val
);
823 val
= access_value_history (0);
825 if (voidprint
|| (val
&& VALUE_TYPE (val
) &&
826 TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_VOID
))
828 int histindex
= record_latest_value (val
);
831 annotate_value_history_begin (histindex
, VALUE_TYPE (val
));
833 annotate_value_begin (VALUE_TYPE (val
));
836 printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"", exp
, histindex
);
838 if (histindex
>= 0) printf_filtered ("$%d = ", histindex
);
841 annotate_value_history_value ();
843 print_formatted (val
, format
, fmt
.size
);
844 printf_filtered ("\n");
847 annotate_value_history_end ();
849 annotate_value_end ();
852 printf_unfiltered("\") )\030");
856 do_cleanups (old_chain
);
857 inspect_it
= 0; /* Reset print routines to normal */
862 print_command (exp
, from_tty
)
866 print_command_1 (exp
, 0, 1);
869 /* Same as print, except in epoch, it gets its own window */
872 inspect_command (exp
, from_tty
)
876 extern int epoch_interface
;
878 print_command_1 (exp
, epoch_interface
, 1);
881 /* Same as print, except it doesn't print void results. */
884 call_command (exp
, from_tty
)
888 print_command_1 (exp
, 0, 0);
893 output_command (exp
, from_tty
)
897 struct expression
*expr
;
898 register struct cleanup
*old_chain
;
899 register char format
= 0;
900 register value_ptr val
;
901 struct format_data fmt
;
903 if (exp
&& *exp
== '/')
906 fmt
= decode_format (&exp
, 0, 0);
907 validate_format (fmt
, "output");
911 expr
= parse_expression (exp
);
912 old_chain
= make_cleanup (free_current_contents
, &expr
);
914 val
= evaluate_expression (expr
);
916 annotate_value_begin (VALUE_TYPE (val
));
918 print_formatted (val
, format
, fmt
.size
);
920 annotate_value_end ();
922 do_cleanups (old_chain
);
927 set_command (exp
, from_tty
)
931 struct expression
*expr
= parse_expression (exp
);
932 register struct cleanup
*old_chain
933 = make_cleanup (free_current_contents
, &expr
);
934 evaluate_expression (expr
);
935 do_cleanups (old_chain
);
940 address_info (exp
, from_tty
)
944 register struct symbol
*sym
;
945 register struct minimal_symbol
*msymbol
;
947 register long basereg
;
948 int is_a_field_of_this
; /* C++: lookup_symbol sets this to nonzero
949 if exp is a field of `this'. */
952 error ("Argument required.");
954 sym
= lookup_symbol (exp
, get_selected_block (), VAR_NAMESPACE
,
955 &is_a_field_of_this
, (struct symtab
**)NULL
);
958 if (is_a_field_of_this
)
960 printf_filtered ("Symbol \"");
961 fprintf_symbol_filtered (gdb_stdout
, exp
,
962 current_language
->la_language
, DMGL_ANSI
);
963 printf_filtered ("\" is a field of the local class variable `this'\n");
967 msymbol
= lookup_minimal_symbol (exp
, (struct objfile
*) NULL
);
971 printf_filtered ("Symbol \"");
972 fprintf_symbol_filtered (gdb_stdout
, exp
,
973 current_language
->la_language
, DMGL_ANSI
);
974 printf_filtered ("\" is at ");
975 print_address_numeric (SYMBOL_VALUE_ADDRESS (msymbol
), 1,
977 printf_filtered (" in a file compiled without debugging.\n");
980 error ("No symbol \"%s\" in current context.", exp
);
984 printf_filtered ("Symbol \"");
985 fprintf_symbol_filtered (gdb_stdout
, SYMBOL_NAME (sym
),
986 current_language
->la_language
, DMGL_ANSI
);
987 printf_filtered ("\" is ", SYMBOL_NAME (sym
));
988 val
= SYMBOL_VALUE (sym
);
989 basereg
= SYMBOL_BASEREG (sym
);
991 switch (SYMBOL_CLASS (sym
))
994 case LOC_CONST_BYTES
:
995 printf_filtered ("constant");
999 printf_filtered ("a label at address ");
1000 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
), 1, gdb_stdout
);
1004 printf_filtered ("a variable in register %s", reg_names
[val
]);
1008 printf_filtered ("static storage at address ");
1009 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
), 1, gdb_stdout
);
1013 printf_filtered ("an argument in register %s", reg_names
[val
]);
1016 case LOC_REGPARM_ADDR
:
1017 printf_filtered ("address of an argument in register %s", reg_names
[val
]);
1021 printf_filtered ("an argument at offset %ld", val
);
1025 printf_filtered ("an argument at frame offset %ld", val
);
1029 printf_filtered ("a local variable at frame offset %ld", val
);
1033 printf_filtered ("a reference argument at offset %ld", val
);
1037 printf_filtered ("a variable at offset %ld from register %s",
1038 val
, reg_names
[basereg
]);
1041 case LOC_BASEREG_ARG
:
1042 printf_filtered ("an argument at offset %ld from register %s",
1043 val
, reg_names
[basereg
]);
1047 printf_filtered ("a typedef");
1051 printf_filtered ("a function at address ");
1052 print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)), 1,
1056 case LOC_OPTIMIZED_OUT
:
1057 printf_filtered ("optimized out");
1061 printf_filtered ("of unknown (botched) type");
1064 printf_filtered (".\n");
1068 x_command (exp
, from_tty
)
1072 struct expression
*expr
;
1073 struct format_data fmt
;
1074 struct cleanup
*old_chain
;
1077 fmt
.format
= last_format
;
1078 fmt
.size
= last_size
;
1081 if (exp
&& *exp
== '/')
1084 fmt
= decode_format (&exp
, last_format
, last_size
);
1087 /* If we have an expression, evaluate it and use it as the address. */
1089 if (exp
!= 0 && *exp
!= 0)
1091 expr
= parse_expression (exp
);
1092 /* Cause expression not to be there any more
1093 if this command is repeated with Newline.
1094 But don't clobber a user-defined command's definition. */
1097 old_chain
= make_cleanup (free_current_contents
, &expr
);
1098 val
= evaluate_expression (expr
);
1099 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_REF
)
1100 val
= value_ind (val
);
1101 /* In rvalue contexts, such as this, functions are coerced into
1102 pointers to functions. This makes "x/i main" work. */
1103 if (/* last_format == 'i'
1104 && */ TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FUNC
1105 && VALUE_LVAL (val
) == lval_memory
)
1106 next_address
= VALUE_ADDRESS (val
);
1108 next_address
= value_as_pointer (val
);
1109 do_cleanups (old_chain
);
1112 do_examine (fmt
, next_address
);
1114 /* If the examine succeeds, we remember its size and format for next time. */
1115 last_size
= fmt
.size
;
1116 last_format
= fmt
.format
;
1118 /* Set a couple of internal variables if appropriate. */
1119 if (last_examine_value
)
1121 /* Make last address examined available to the user as $_. Use
1122 the correct pointer type. */
1123 set_internalvar (lookup_internalvar ("_"),
1124 value_from_longest (
1125 lookup_pointer_type (VALUE_TYPE (last_examine_value
)),
1126 (LONGEST
) last_examine_address
));
1128 /* Make contents of last address examined available to the user as $__.*/
1129 set_internalvar (lookup_internalvar ("__"), last_examine_value
);
1134 /* Add an expression to the auto-display chain.
1135 Specify the expression. */
1138 display_command (exp
, from_tty
)
1142 struct format_data fmt
;
1143 register struct expression
*expr
;
1144 register struct display
*new;
1155 fmt
= decode_format (&exp
, 0, 0);
1156 if (fmt
.size
&& fmt
.format
== 0)
1158 if (fmt
.format
== 'i' || fmt
.format
== 's')
1168 innermost_block
= 0;
1169 expr
= parse_expression (exp
);
1171 new = (struct display
*) xmalloc (sizeof (struct display
));
1174 new->block
= innermost_block
;
1175 new->next
= display_chain
;
1176 new->number
= ++display_number
;
1178 new->status
= enabled
;
1179 display_chain
= new;
1181 if (from_tty
&& target_has_execution
)
1182 do_one_display (new);
1195 /* Clear out the display_chain.
1196 Done when new symtabs are loaded, since this invalidates
1197 the types stored in many expressions. */
1202 register struct display
*d
;
1204 while ((d
= display_chain
) != NULL
)
1207 display_chain
= d
->next
;
1212 /* Delete the auto-display number NUM. */
1215 delete_display (num
)
1218 register struct display
*d1
, *d
;
1221 error ("No display number %d.", num
);
1223 if (display_chain
->number
== num
)
1226 display_chain
= d1
->next
;
1230 for (d
= display_chain
; ; d
= d
->next
)
1233 error ("No display number %d.", num
);
1234 if (d
->next
->number
== num
)
1244 /* Delete some values from the auto-display chain.
1245 Specify the element numbers. */
1248 undisplay_command (args
, from_tty
)
1252 register char *p
= args
;
1258 if (query ("Delete all auto-display expressions? "))
1267 while (*p1
>= '0' && *p1
<= '9') p1
++;
1268 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1269 error ("Arguments must be display numbers.");
1273 delete_display (num
);
1276 while (*p
== ' ' || *p
== '\t') p
++;
1281 /* Display a single auto-display.
1282 Do nothing if the display cannot be printed in the current context,
1283 or if the display is disabled. */
1289 int within_current_scope
;
1291 if (d
->status
== disabled
)
1295 within_current_scope
= contained_in (get_selected_block (), d
->block
);
1297 within_current_scope
= 1;
1298 if (!within_current_scope
)
1301 current_display_number
= d
->number
;
1303 annotate_display_begin ();
1304 printf_filtered ("%d", d
->number
);
1305 annotate_display_number_end ();
1306 printf_filtered (": ");
1311 annotate_display_format ();
1313 printf_filtered ("x/");
1314 if (d
->format
.count
!= 1)
1315 printf_filtered ("%d", d
->format
.count
);
1316 printf_filtered ("%c", d
->format
.format
);
1317 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1318 printf_filtered ("%c", d
->format
.size
);
1319 printf_filtered (" ");
1321 annotate_display_expression ();
1323 print_expression (d
->exp
, gdb_stdout
);
1324 annotate_display_expression_end ();
1326 if (d
->format
.count
!= 1)
1327 printf_filtered ("\n");
1329 printf_filtered (" ");
1331 addr
= value_as_pointer (evaluate_expression (d
->exp
));
1332 if (d
->format
.format
== 'i')
1333 addr
= ADDR_BITS_REMOVE (addr
);
1335 annotate_display_value ();
1337 do_examine (d
->format
, addr
);
1341 annotate_display_format ();
1343 if (d
->format
.format
)
1344 printf_filtered ("/%c ", d
->format
.format
);
1346 annotate_display_expression ();
1348 print_expression (d
->exp
, gdb_stdout
);
1349 annotate_display_expression_end ();
1351 printf_filtered (" = ");
1353 annotate_display_expression ();
1355 print_formatted (evaluate_expression (d
->exp
),
1356 d
->format
.format
, d
->format
.size
);
1357 printf_filtered ("\n");
1360 annotate_display_end ();
1362 gdb_flush (gdb_stdout
);
1363 current_display_number
= -1;
1366 /* Display all of the values on the auto-display chain which can be
1367 evaluated in the current scope. */
1372 register struct display
*d
;
1374 for (d
= display_chain
; d
; d
= d
->next
)
1378 /* Delete the auto-display which we were in the process of displaying.
1379 This is done when there is an error or a signal. */
1382 disable_display (num
)
1385 register struct display
*d
;
1387 for (d
= display_chain
; d
; d
= d
->next
)
1388 if (d
->number
== num
)
1390 d
->status
= disabled
;
1393 printf_unfiltered ("No display number %d.\n", num
);
1397 disable_current_display ()
1399 if (current_display_number
>= 0)
1401 disable_display (current_display_number
);
1402 fprintf_unfiltered (gdb_stderr
, "Disabling display %d to avoid infinite recursion.\n",
1403 current_display_number
);
1405 current_display_number
= -1;
1409 display_info (ignore
, from_tty
)
1413 register struct display
*d
;
1416 printf_unfiltered ("There are no auto-display expressions now.\n");
1418 printf_filtered ("Auto-display expressions now in effect:\n\
1419 Num Enb Expression\n");
1421 for (d
= display_chain
; d
; d
= d
->next
)
1423 printf_filtered ("%d: %c ", d
->number
, "ny"[(int)d
->status
]);
1425 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
1427 else if (d
->format
.format
)
1428 printf_filtered ("/%c ", d
->format
.format
);
1429 print_expression (d
->exp
, gdb_stdout
);
1430 if (d
->block
&& !contained_in (get_selected_block (), d
->block
))
1431 printf_filtered (" (cannot be evaluated in the current context)");
1432 printf_filtered ("\n");
1433 gdb_flush (gdb_stdout
);
1438 enable_display (args
, from_tty
)
1442 register char *p
= args
;
1445 register struct display
*d
;
1449 for (d
= display_chain
; d
; d
= d
->next
)
1450 d
->status
= enabled
;
1456 while (*p1
>= '0' && *p1
<= '9')
1458 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1459 error ("Arguments must be display numbers.");
1463 for (d
= display_chain
; d
; d
= d
->next
)
1464 if (d
->number
== num
)
1466 d
->status
= enabled
;
1469 printf_unfiltered ("No display number %d.\n", num
);
1472 while (*p
== ' ' || *p
== '\t')
1479 disable_display_command (args
, from_tty
)
1483 register char *p
= args
;
1485 register struct display
*d
;
1489 for (d
= display_chain
; d
; d
= d
->next
)
1490 d
->status
= disabled
;
1496 while (*p1
>= '0' && *p1
<= '9')
1498 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1499 error ("Arguments must be display numbers.");
1501 disable_display (atoi (p
));
1504 while (*p
== ' ' || *p
== '\t')
1510 /* Print the value in stack frame FRAME of a variable
1511 specified by a struct symbol. */
1514 print_variable_value (var
, frame
, stream
)
1519 value_ptr val
= read_var_value (var
, frame
);
1520 value_print (val
, stream
, 0, Val_pretty_default
);
1523 /* Print the arguments of a stack frame, given the function FUNC
1524 running in that frame (as a symbol), the info on the frame,
1525 and the number of args according to the stack frame (or -1 if unknown). */
1527 /* References here and elsewhere to "number of args according to the
1528 stack frame" appear in all cases to refer to "number of ints of args
1529 according to the stack frame". At least for VAX, i386, isi. */
1532 print_frame_args (func
, fi
, num
, stream
)
1533 struct symbol
*func
;
1534 struct frame_info
*fi
;
1538 struct block
*b
= NULL
;
1542 register struct symbol
*sym
;
1543 register value_ptr val
;
1544 /* Offset of next stack argument beyond the one we have seen that is
1545 at the highest offset.
1546 -1 if we haven't come to a stack argument yet. */
1547 long highest_offset
= -1;
1549 /* Number of ints of arguments that we have printed so far. */
1550 int args_printed
= 0;
1554 b
= SYMBOL_BLOCK_VALUE (func
);
1555 nsyms
= BLOCK_NSYMS (b
);
1558 for (i
= 0; i
< nsyms
; i
++)
1561 sym
= BLOCK_SYM (b
, i
);
1563 /* Keep track of the highest stack argument offset seen, and
1564 skip over any kinds of symbols we don't care about. */
1566 switch (SYMBOL_CLASS (sym
)) {
1570 long current_offset
= SYMBOL_VALUE (sym
);
1572 arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
1574 /* Compute address of next argument by adding the size of
1575 this argument and rounding to an int boundary. */
1577 = ((current_offset
+ arg_size
+ sizeof (int) - 1)
1578 & ~(sizeof (int) - 1));
1580 /* If this is the highest offset seen yet, set highest_offset. */
1581 if (highest_offset
== -1
1582 || (current_offset
> highest_offset
))
1583 highest_offset
= current_offset
;
1585 /* Add the number of ints we're about to print to args_printed. */
1586 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
1589 /* We care about types of symbols, but don't need to keep track of
1590 stack offsets in them. */
1592 case LOC_REGPARM_ADDR
:
1594 case LOC_BASEREG_ARG
:
1597 /* Other types of symbols we just skip over. */
1602 /* We have to look up the symbol because arguments can have
1603 two entries (one a parameter, one a local) and the one we
1604 want is the local, which lookup_symbol will find for us.
1605 This includes gcc1 (not gcc2) on the sparc when passing a
1606 small structure and gcc2 when the argument type is float
1607 and it is passed as a double and converted to float by
1608 the prologue (in the latter case the type of the LOC_ARG
1609 symbol is double and the type of the LOC_LOCAL symbol is
1611 /* But if the parameter name is null, don't try it.
1612 Null parameter names occur on the RS/6000, for traceback tables.
1613 FIXME, should we even print them? */
1615 if (*SYMBOL_NAME (sym
))
1617 struct symbol
*nsym
;
1618 nsym
= lookup_symbol
1620 b
, VAR_NAMESPACE
, (int *)NULL
, (struct symtab
**)NULL
);
1621 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
)
1623 /* There is a LOC_ARG/LOC_REGISTER pair. This means that
1624 it was passed on the stack and loaded into a register,
1625 or passed in a register and stored in a stack slot.
1626 GDB 3.x used the LOC_ARG; GDB 4.0-4.11 used the LOC_REGISTER.
1628 Reasons for using the LOC_ARG:
1629 (1) because find_saved_registers may be slow for remote
1631 (2) because registers are often re-used and stack slots
1632 rarely (never?) are. Therefore using the stack slot is
1633 much less likely to print garbage.
1635 Reasons why we might want to use the LOC_REGISTER:
1636 (1) So that the backtrace prints the same value as
1637 "print foo". I see no compelling reason why this needs
1638 to be the case; having the backtrace print the value which
1639 was passed in, and "print foo" print the value as modified
1640 within the called function, makes perfect sense to me.
1642 Additional note: It might be nice if "info args" displayed
1644 One more note: There is a case with sparc structure passing
1645 where we need to use the LOC_REGISTER, but this is dealt with
1646 by creating a single LOC_REGPARM in symbol reading. */
1648 /* Leave sym (the LOC_ARG) alone. */
1655 /* Print the current arg. */
1657 fprintf_filtered (stream
, ", ");
1660 annotate_arg_begin ();
1662 fprintf_symbol_filtered (stream
, SYMBOL_SOURCE_NAME (sym
),
1663 SYMBOL_LANGUAGE (sym
), DMGL_PARAMS
| DMGL_ANSI
);
1664 annotate_arg_name_end ();
1665 fputs_filtered ("=", stream
);
1667 /* Avoid value_print because it will deref ref parameters. We just
1668 want to print their addresses. Print ??? for args whose address
1669 we do not know. We pass 2 as "recurse" to val_print because our
1670 standard indentation here is 4 spaces, and val_print indents
1671 2 for each recurse. */
1672 val
= read_var_value (sym
, FRAME_INFO_ID (fi
));
1674 annotate_arg_value (val
== NULL
? NULL
: VALUE_TYPE (val
));
1677 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
), VALUE_ADDRESS (val
),
1678 stream
, 0, 0, 2, Val_no_prettyprint
);
1680 fputs_filtered ("???", stream
);
1682 annotate_arg_end ();
1687 /* Don't print nameless args in situations where we don't know
1688 enough about the stack to find them. */
1693 if (highest_offset
== -1)
1694 start
= FRAME_ARGS_SKIP
;
1696 start
= highest_offset
;
1698 print_frame_nameless_args (fi
, start
, num
- args_printed
,
1703 /* Print nameless args on STREAM.
1704 FI is the frameinfo for this frame, START is the offset
1705 of the first nameless arg, and NUM is the number of nameless args to
1706 print. FIRST is nonzero if this is the first argument (not just
1707 the first nameless arg). */
1709 print_frame_nameless_args (fi
, start
, num
, first
, stream
)
1710 struct frame_info
*fi
;
1720 for (i
= 0; i
< num
; i
++)
1723 #ifdef NAMELESS_ARG_VALUE
1724 NAMELESS_ARG_VALUE (fi
, start
, &arg_value
);
1726 argsaddr
= FRAME_ARGS_ADDRESS (fi
);
1730 arg_value
= read_memory_integer (argsaddr
+ start
, sizeof (int));
1734 fprintf_filtered (stream
, ", ");
1736 #ifdef PRINT_NAMELESS_INTEGER
1737 PRINT_NAMELESS_INTEGER (stream
, arg_value
);
1739 #ifdef PRINT_TYPELESS_INTEGER
1740 PRINT_TYPELESS_INTEGER (stream
, builtin_type_int
, (LONGEST
) arg_value
);
1742 fprintf_filtered (stream
, "%d", arg_value
);
1743 #endif /* PRINT_TYPELESS_INTEGER */
1744 #endif /* PRINT_NAMELESS_INTEGER */
1746 start
+= sizeof (int);
1752 printf_command (arg
, from_tty
)
1757 register char *s
= arg
;
1759 value_ptr
*val_args
;
1761 char *current_substring
;
1763 int allocated_args
= 20;
1764 struct cleanup
*old_cleanups
;
1766 val_args
= (value_ptr
*) xmalloc (allocated_args
* sizeof (value_ptr
));
1767 old_cleanups
= make_cleanup (free_current_contents
, &val_args
);
1770 error_no_arg ("format-control string and values to print");
1772 /* Skip white space before format string */
1773 while (*s
== ' ' || *s
== '\t') s
++;
1775 /* A format string should follow, enveloped in double quotes */
1777 error ("Bad format string, missing '\"'.");
1779 /* Parse the format-control string and copy it into the string STRING,
1780 processing some kinds of escape sequence. */
1782 f
= string
= (char *) alloca (strlen (s
) + 1);
1790 error ("Bad format string, non-terminated '\"'.");
1802 *f
++ = '\007'; /* Bell */
1827 /* ??? TODO: handle other escape sequences */
1828 error ("Unrecognized escape character \\%c in format string.",
1838 /* Skip over " and following space and comma. */
1841 while (*s
== ' ' || *s
== '\t') s
++;
1843 if (*s
!= ',' && *s
!= 0)
1844 error ("Invalid argument syntax");
1847 while (*s
== ' ' || *s
== '\t') s
++;
1849 /* Need extra space for the '\0's. Doubling the size is sufficient. */
1850 substrings
= alloca (strlen (string
) * 2);
1851 current_substring
= substrings
;
1854 /* Now scan the string for %-specs and see what kinds of args they want.
1855 argclass[I] classifies the %-specs so we can give vprintf_unfiltered something
1856 of the right size. */
1858 enum argclass
{no_arg
, int_arg
, string_arg
, double_arg
, long_long_arg
};
1859 enum argclass
*argclass
;
1860 enum argclass this_argclass
;
1866 argclass
= (enum argclass
*) alloca (strlen (s
) * sizeof *argclass
);
1874 while (strchr ("0123456789.hlL-+ #", *f
))
1876 if (*f
== 'l' || *f
== 'L')
1883 this_argclass
= string_arg
;
1889 this_argclass
= double_arg
;
1893 error ("`*' not supported for precision or width in printf");
1896 error ("Format specifier `n' not supported in printf");
1899 this_argclass
= no_arg
;
1904 this_argclass
= long_long_arg
;
1906 this_argclass
= int_arg
;
1910 if (this_argclass
!= no_arg
)
1912 strncpy (current_substring
, last_arg
, f
- last_arg
);
1913 current_substring
+= f
- last_arg
;
1914 *current_substring
++ = '\0';
1916 argclass
[nargs_wanted
++] = this_argclass
;
1920 /* Now, parse all arguments and evaluate them.
1921 Store the VALUEs in VAL_ARGS. */
1926 if (nargs
== allocated_args
)
1927 val_args
= (value_ptr
*) xrealloc ((char *) val_args
,
1928 (allocated_args
*= 2)
1929 * sizeof (value_ptr
));
1931 val_args
[nargs
] = parse_to_comma_and_eval (&s1
);
1933 /* If format string wants a float, unchecked-convert the value to
1934 floating point of the same size */
1936 if (argclass
[nargs
] == double_arg
)
1938 if (TYPE_LENGTH (VALUE_TYPE (val_args
[nargs
])) == sizeof (float))
1939 VALUE_TYPE (val_args
[nargs
]) = builtin_type_float
;
1940 if (TYPE_LENGTH (VALUE_TYPE (val_args
[nargs
])) == sizeof (double))
1941 VALUE_TYPE (val_args
[nargs
]) = builtin_type_double
;
1949 if (nargs
!= nargs_wanted
)
1950 error ("Wrong number of arguments for specified format-string");
1952 /* FIXME: We should be using vprintf_filtered, but as long as it
1953 has an arbitrary limit that is unacceptable. Correct fix is
1954 for vprintf_filtered to scan down the format string so it knows
1955 how big a buffer it needs (perhaps by putting a vasprintf (see
1956 GNU C library) in libiberty).
1958 But for now, just force out any pending output, so at least the output
1959 appears in the correct order. */
1960 wrap_here ((char *)NULL
);
1962 /* Now actually print them. */
1963 current_substring
= substrings
;
1964 for (i
= 0; i
< nargs
; i
++)
1966 switch (argclass
[i
])
1973 tem
= value_as_pointer (val_args
[i
]);
1975 /* This is a %s argument. Find the length of the string. */
1980 read_memory (tem
+ j
, &c
, 1);
1985 /* Copy the string contents into a string inside GDB. */
1986 str
= (char *) alloca (j
+ 1);
1987 read_memory (tem
, str
, j
);
1990 /* Don't use printf_filtered because of arbitrary limit. */
1991 printf_unfiltered (current_substring
, str
);
1996 double val
= value_as_double (val_args
[i
]);
1997 /* Don't use printf_filtered because of arbitrary limit. */
1998 printf_unfiltered (current_substring
, val
);
2002 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2004 long long val
= value_as_long (val_args
[i
]);
2005 /* Don't use printf_filtered because of arbitrary limit. */
2006 printf_unfiltered (current_substring
, val
);
2010 error ("long long not supported in printf");
2014 /* FIXME: there should be separate int_arg and long_arg. */
2015 long val
= value_as_long (val_args
[i
]);
2016 /* Don't use printf_filtered because of arbitrary limit. */
2017 printf_unfiltered (current_substring
, val
);
2021 error ("internal error in printf_command");
2023 /* Skip to the next substring. */
2024 current_substring
+= strlen (current_substring
) + 1;
2026 /* Print the portion of the format string after the last argument. */
2027 /* It would be OK to use printf_filtered here. */
2030 do_cleanups (old_cleanups
);
2033 /* Dump a specified section of assembly code. With no command line
2034 arguments, this command will dump the assembly code for the
2035 function surrounding the pc value in the selected frame. With one
2036 argument, it will dump the assembly code surrounding that pc value.
2037 Two arguments are interpeted as bounds within which to dump
2042 disassemble_command (arg
, from_tty
)
2046 CORE_ADDR low
, high
;
2054 if (!selected_frame
)
2055 error ("No frame selected.\n");
2057 pc
= get_frame_pc (selected_frame
);
2058 if (find_pc_partial_function (pc
, &name
, &low
, &high
) == 0)
2059 error ("No function contains program counter for selected frame.\n");
2061 else if (!(space_index
= (char *) strchr (arg
, ' ')))
2064 pc
= parse_and_eval_address (arg
);
2065 if (find_pc_partial_function (pc
, &name
, &low
, &high
) == 0)
2066 error ("No function contains specified address.\n");
2070 /* Two arguments. */
2071 *space_index
= '\0';
2072 low
= parse_and_eval_address (arg
);
2073 high
= parse_and_eval_address (space_index
+ 1);
2076 printf_filtered ("Dump of assembler code ");
2079 printf_filtered ("for function %s:\n", name
);
2083 printf_filtered ("from ");
2084 print_address_numeric (low
, 1, gdb_stdout
);
2085 printf_filtered (" to ");
2086 print_address_numeric (high
, 1, gdb_stdout
);
2087 printf_filtered (":\n");
2090 /* Dump the specified range. */
2091 for (pc
= low
; pc
< high
; )
2094 print_address (pc
, gdb_stdout
);
2095 printf_filtered (":\t");
2096 /* We often wrap here if there are long symbolic names. */
2098 pc
+= print_insn (pc
, gdb_stdout
);
2099 printf_filtered ("\n");
2101 printf_filtered ("End of assembler dump.\n");
2102 gdb_flush (gdb_stdout
);
2107 _initialize_printcmd ()
2109 current_display_number
= -1;
2111 add_info ("address", address_info
,
2112 "Describe where variable VAR is stored.");
2114 add_com ("x", class_vars
, x_command
,
2115 "Examine memory: x/FMT ADDRESS.\n\
2116 ADDRESS is an expression for the memory address to examine.\n\
2117 FMT is a repeat count followed by a format letter and a size letter.\n\
2118 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2119 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n\
2120 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2121 The specified number of objects of the specified size are printed\n\
2122 according to the format.\n\n\
2123 Defaults for format and size letters are those previously used.\n\
2124 Default count is 1. Default address is following last thing printed\n\
2125 with this command or \"print\".");
2127 add_com ("disassemble", class_vars
, disassemble_command
,
2128 "Disassemble a specified section of memory.\n\
2129 Default is the function surrounding the pc of the selected frame.\n\
2130 With a single argument, the function surrounding that address is dumped.\n\
2131 Two arguments are taken as a range of memory to dump.");
2134 add_com ("whereis", class_vars
, whereis_command
,
2135 "Print line number and file of definition of variable.");
2138 add_info ("display", display_info
,
2139 "Expressions to display when program stops, with code numbers.");
2141 add_cmd ("undisplay", class_vars
, undisplay_command
,
2142 "Cancel some expressions to be displayed when program stops.\n\
2143 Arguments are the code numbers of the expressions to stop displaying.\n\
2144 No argument means cancel all automatic-display expressions.\n\
2145 \"delete display\" has the same effect as this command.\n\
2146 Do \"info display\" to see current list of code numbers.",
2149 add_com ("display", class_vars
, display_command
,
2150 "Print value of expression EXP each time the program stops.\n\
2151 /FMT may be used before EXP as in the \"print\" command.\n\
2152 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2153 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2154 and examining is done as in the \"x\" command.\n\n\
2155 With no argument, display all currently requested auto-display expressions.\n\
2156 Use \"undisplay\" to cancel display requests previously made.");
2158 add_cmd ("display", class_vars
, enable_display
,
2159 "Enable some expressions to be displayed when program stops.\n\
2160 Arguments are the code numbers of the expressions to resume displaying.\n\
2161 No argument means enable all automatic-display expressions.\n\
2162 Do \"info display\" to see current list of code numbers.", &enablelist
);
2164 add_cmd ("display", class_vars
, disable_display_command
,
2165 "Disable some expressions to be displayed when program stops.\n\
2166 Arguments are the code numbers of the expressions to stop displaying.\n\
2167 No argument means disable all automatic-display expressions.\n\
2168 Do \"info display\" to see current list of code numbers.", &disablelist
);
2170 add_cmd ("display", class_vars
, undisplay_command
,
2171 "Cancel some expressions to be displayed when program stops.\n\
2172 Arguments are the code numbers of the expressions to stop displaying.\n\
2173 No argument means cancel all automatic-display expressions.\n\
2174 Do \"info display\" to see current list of code numbers.", &deletelist
);
2176 add_com ("printf", class_vars
, printf_command
,
2177 "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2178 This is useful for formatted output in user-defined commands.");
2179 add_com ("output", class_vars
, output_command
,
2180 "Like \"print\" but don't put in value history and don't print newline.\n\
2181 This is useful in user-defined commands.");
2183 add_prefix_cmd ("set", class_vars
, set_command
,
2184 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2185 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2186 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2187 with $), a register (a few standard names starting with $), or an actual\n\
2188 variable in the program being debugged. EXP is any valid expression.\n\
2189 Use \"set variable\" for variables with names identical to set subcommands.\n\
2190 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2191 You can see these environment settings with the \"show\" command.",
2192 &setlist
, "set ", 1, &cmdlist
);
2194 /* "call" is the same as "set", but handy for dbx users to call fns. */
2195 add_com ("call", class_vars
, call_command
,
2196 "Call a function in the program.\n\
2197 The argument is the function name and arguments, in the notation of the\n\
2198 current working language. The result is printed and saved in the value\n\
2199 history, if it is not void.");
2201 add_cmd ("variable", class_vars
, set_command
,
2202 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2203 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2204 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2205 with $), a register (a few standard names starting with $), or an actual\n\
2206 variable in the program being debugged. EXP is any valid expression.\n\
2207 This may usually be abbreviated to simply \"set\".",
2210 add_com ("print", class_vars
, print_command
,
2211 concat ("Print value of expression EXP.\n\
2212 Variables accessible are those of the lexical environment of the selected\n\
2213 stack frame, plus all those whose scope is global or an entire file.\n\
2215 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2216 $$NUM refers to NUM'th value back from the last one.\n\
2217 Names starting with $ refer to registers (with the values they would have\n\
2218 if the program were to return to the stack frame now selected, restoring\n\
2219 all registers saved by frames farther in) or else to debugger\n\
2220 \"convenience\" variables (any such name not a known register).\n\
2221 Use assignment expressions to give values to convenience variables.\n",
2223 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2224 @ is a binary operator for treating consecutive data objects\n\
2225 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2226 element is FOO, whose second element is stored in the space following\n\
2227 where FOO is stored, etc. FOO must be an expression whose value\n\
2228 resides in memory.\n",
2230 EXP may be preceded with /FMT, where FMT is a format letter\n\
2231 but no count or size letter (see \"x\" command).", NULL
));
2232 add_com_alias ("p", "print", class_vars
, 1);
2234 add_com ("inspect", class_vars
, inspect_command
,
2235 "Same as \"print\" command, except that if you are running in the epoch\n\
2236 environment, the value is printed in its own window.");
2239 add_set_cmd ("max-symbolic-offset", no_class
, var_uinteger
,
2240 (char *)&max_symbolic_offset
,
2241 "Set the largest offset that will be printed in <symbol+1234> form.",
2245 add_set_cmd ("symbol-filename", no_class
, var_boolean
,
2246 (char *)&print_symbol_filename
,
2247 "Set printing of source filename and line number with <symbol>.",
2251 examine_b_type
= init_type (TYPE_CODE_INT
, 1, 0, NULL
, NULL
);
2252 examine_h_type
= init_type (TYPE_CODE_INT
, 2, 0, NULL
, NULL
);
2253 examine_w_type
= init_type (TYPE_CODE_INT
, 4, 0, NULL
, NULL
);
2254 examine_g_type
= init_type (TYPE_CODE_INT
, 8, 0, NULL
, NULL
);